线程池

## 线程池

通过例子理解

• 例1

package com.example.test;

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;

/**
 * 核心线程数：5，最大线程数：10，有界阻塞队列长度：5
 *
 * @author mdl
 * @date 2020/5/14 14:21
 */
public class ThreadPoolTest {

    public static void main(String[] args) {
        int corePoolSize = 5;
        int maximumPoolSize = 10;
        int queueSize = 5;

        ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build();
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(queueSize);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 0, TimeUnit.MILLISECONDS,
                workQueue, namedThreadFactory, new MyIgnorePolicy());

        for(int i =0; i< 10 ;i++){
            executor.submit(new Handle());
        }
        // 效果：打印了前5个任务，10s后打印后5个任务
        // 结论1：来了5个任务(假定任务执行时间较长),这时再来任务，将进入阻塞队列，核心线程空闲时处理
        // ----------------------------------------------------

    }

    public static class MyIgnorePolicy implements RejectedExecutionHandler {

        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.err.println(r.toString() + " rejected");
        }
    }


    static class Handle implements Runnable{

        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "--- executor...");
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

红框内的再10s后出现的

结论：来了5个任务(假定任务执行时间较长),这时再来任务，将进入阻塞队列，核心线程空闲时处理

• 例2

  package com.example.test;
  
  import com.google.common.util.concurrent.ThreadFactoryBuilder;
  
  import java.util.concurrent.*;
  
  /**
   * 核心线程数：5，最大线程数：10，有界阻塞队列长度：5
   *
   * @author mdl
   * @date 2020/5/14 14:21
   */
  public class ThreadPoolTest {
  
      public static void main(String[] args) {
          int corePoolSize = 5;
          int maximumPoolSize = 10;
          int queueSize = 5;
  
          ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build();
          BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(queueSize);
          ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 0, TimeUnit.MILLISECONDS,
                  workQueue, namedThreadFactory, new MyIgnorePolicy());
  
  //        for(int i =0; i< 10 ;i++){
  //            executor.submit(new Handle());
  //        }
          // 效果：打印了前5个任务，10s后打印后5个任务
          // 结论1：来了5个任务(假定任务执行时间较长),这时再来任务，将进入阻塞队列，核心线程空闲时处理
          // ----------------------------------------------------
          for(int i =0; i< 15 ;i++){
              executor.submit(new Handle());
          }
          // 效果：先打印了10个线程执行，10s后打印5个
          // 结论：第1~5进来的任务由核心线程执行，第6~10将进入阻塞任务队列，第11~15个任务由临时线程执行
          // 核心线程或者临时线程空闲出来后去取阻塞任务队列里的任务执行
      }
  
      public static class MyIgnorePolicy implements RejectedExecutionHandler {
  
          @Override
          public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
              System.err.println(r.toString() + " rejected");
          }
      }
      
      static class Handle implements Runnable{
  
          @Override
          public void run() {
              System.out.println(Thread.currentThread().getName() + "--- executor...");
              try {
                  Thread.sleep(10000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }
  

  

红框里的10s后才显示

结论：第1~5进来的任务由核心线程执行，第6~10将进入阻塞任务队列，第11~15个任务由临时线程执行

核心线程或者临时线程空闲出来后去取阻塞任务队列里的任务执行

• 例3

  package com.example.test;
  
  import com.google.common.util.concurrent.ThreadFactoryBuilder;
  
  import java.util.concurrent.*;
  
  /**
   * 核心线程数：5，最大线程数：10，有界阻塞队列长度：5
   *
   * @author mdl
   * @date 2020/5/14 14:21
   */
  public class ThreadPoolTest {
  
      public static void main(String[] args) {
          int corePoolSize = 5;
          int maximumPoolSize = 10;
          int queueSize = 5;
  
          ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build();
          BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(queueSize);
          ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 0, TimeUnit.MILLISECONDS,
                  workQueue, namedThreadFactory, new MyIgnorePolicy());
  
  //        for(int i =0; i< 10 ;i++){
  //            executor.submit(new Handle());
  //        }
          // 效果：打印了前5个任务，10s后打印后5个任务
          // 结论1：来了5个任务(假定任务执行时间较长),这时再来任务，将进入阻塞队列，核心线程空闲时处理
          // ----------------------------------------------------
  //        for(int i =0; i< 15 ;i++){
  //            executor.submit(new Handle());
  //        }
          // 效果：先打印了10个线程执行，10s后打印5个
          // 结论2：第1~5进来的任务由核心线程执行，第6~10将进入阻塞任务队列，第11~15个任务由临时线程执行
          // 核心线程或者临时线程空闲出来后去取阻塞任务队列里的任务执行
          for (int i = 0; i < 16; i++) {
              executor.submit(new Handle());
          }
          // 效果跟2的区别就是第16个任务进来将执行解决策略
      }
  
      public static class MyIgnorePolicy implements RejectedExecutionHandler {
  
          @Override
          public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
              System.err.println(r.toString() + " rejected");
          }
      }
  
  
      static class Handle implements Runnable {
  
          @Override
          public void run() {
              System.out.println(Thread.currentThread().getName() + "--- executor...");
              try {
                  Thread.sleep(10000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }
  

  

红框里的10s后出现

跟例2的区别是：第16个任务进来的时候将执行拒绝策略

总结

小于或等于corePoolSize: 创建核心线程处理任务

大于corePoolSize且小于队列长度：进入阻塞队列

大于corePoolSize+队列长度，小于maxPoolSize+队列长度：创建临时线程处理任务

大于maxPoolSize+队列长度：执行拒绝策略

核心线程和临时线程无论谁空闲出来就去阻塞队列里取任务执行

配置

• 高并发、任务执行时间短：线程数设置CPU核数+1（尽量少），目的是减少线程上下文切换
• 高并发、任务执行时间长：
  1. 数据缓存
  2. 服务器集群
  3. 任务拆分，异步解耦
• 并发低、任务执行时间长：
  1. 瓶颈在磁盘IO, 增加线程数，让CPU都动起来，可以设置CPU核数*2
  2. 业务计算密集（又叫CPU密集型），线程数设置的少些，减少线程上下文切换，配置CPU核数+1

最大可用的处理器数量

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();