线程池系列(一)------------线程池简介

一、简介

             线程池主要解决了俩个问题：一是避免了频繁创建销毁线程所带来的开销，达到了线程复用的目的；二是线程池提供了一种资源限制和管理的手段，用户可以通过一些参数来定制化线程；

二、线程池状态

2.1 原子变量ctl

2.1.1 ThreadPoolExecutor源码

public class ThreadPoolExecutor extends AbstractExecutorService {

    // 该原子变量的高3位用来表示线程池状态，低29位用来表示线程个数(假设Integer为32位时)， 默认是RUNNING状态
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

    /**
     * 线程个数掩码位数，并非所有平台的int类型都是32位的，所以准确的来说，是具体平台下Integer的二进制位数-3后的剩余位数所表示的数才是线程的个数
     */
    private static final int COUNT_BITS = Integer.SIZE - 3;

    
    // 线程的最大个数（低29位 00011111111111111111111111111111）
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    
    // RUNNING状态 高三位为111  （11100000000000000000000000000000）
    private static final int RUNNING    = -1 << COUNT_BITS;
   
    // SHUTDOWN状态 高三位为000 （00000000000000000000000000000000）
    private static final int SHUTDOWN   =  0 << COUNT_BITS;

    // STOP状态  高三位为001    （00100000000000000000000000000000）
    private static final int STOP       =  1 << COUNT_BITS;

    // TIDYING状态 高三位为010  （01000000000000000000000000000000）
    private static final int TIDYING    =  2 << COUNT_BITS;

    // TERMINATED状态 高三位为011（01100000000000000000000000000000）
    private static final int TERMINATED =  3 << COUNT_BITS;
    
    
    // 获取高3位(运行状态)
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
   
    // 获取低29位(线程个数)
    private static int workerCountOf(int c)  { return c & CAPACITY; }

    // 计算ctl新值（线程状态和线程个数）
    private static int ctlOf(int rs, int wc) { return rs | wc; }


}

 

 

2.2 状态转换图

 

2.3 状态详解

2.3.1 RUNNING

• 接受新任务并且处理阻塞队列里的任务；

2.3.2 SHUTDOWN

• 拒绝新任务但是处理阻塞队列里的任务；

2.3.3 STOP

• 拒绝新任务并且抛弃阻塞队列里的任务，同时会中断正在处理的任务；

2.3.4 TIDYING

• 所有任务都执行完（包含阻塞队列里面的任务）后当前线程池活动线程数为0-，将调用terminated方法；

2.3.5 TERMINATED

• 终止状态。terminated方法调用完成以后的状态。

 

三、线程池七大核心参数

3.1 corePoolSize

• 核心线程个数；

3.2 wordQueue

• 用于保存等待执行的任务的阻塞队列，有以下几种：
  • ArrayBlockingQueue: 基于数组的有界阻塞队列；
  • LinedBlockingQueue: 基于链表的无界阻塞队列；
  • SynchronousQueue： 最多只有一个元素的同步队列；
  • PriorityBlockingQueue: 优先级队列；
  • DelayQueue: 无界阻塞延迟队列；

3.3 maximunPoolSize

• 线程池最大线程数量；

3.4 ThreadFactory

• 创建线程的工厂；

3.5 RejectidExecutionHandler

• 饱和策略/拒绝策略，当队列满并且县城个数达到maximunPoolSize后采取的策略，有以下几种：
  • AbortPolicy： 抛出异常；
  • DiscardPolicy: 默默丢弃，不抛出异常；
  • DiscardOldestPolicy： 调用poll丢弃一个任务，执行当前任务；
  • CallerRunsPolicy: 使用调用者所在线程来运行任务；

3.6 keeyAliveTime

• 存活时间。如果当前线程池中的线程数量比核心线程数量多，并且是闲置状态，则这些闲置的线程能存活的最大时间；

3.7 TimeUnit

• 存活时间的时间单位；

 

四、六大线程池类型 TODO

4.1 FixedThreadPool

4.1.1 Executors类中源码

•     /**
       *
       */   
      public static ExecutorService newFixedThreadPool(int nThreads) {
          return new ThreadPoolExecutor(nThreads, nThreads,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue());
      }
  
      
      /**
       *
       */
      public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
          return new ThreadPoolExecutor(nThreads, nThreads,
                                        0L, TimeUnit.MILLISECONDS,
                                        new LinkedBlockingQueue(),
                                        threadFactory);
      }

   

4.1.2 详解

 

4.2 CachedThreadPool

4.2.1 Executors类中源码

•     /**
       *
       */
      public static ExecutorService newCachedThreadPool() {
          return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                        60L, TimeUnit.SECONDS,
                                        new SynchronousQueue());
      }
  
  
      /**
       *
       */
      public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
          return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                        60L, TimeUnit.SECONDS,
                                        new SynchronousQueue(),
                                        threadFactory);
      }

   

4.2.2 详解

 

4.3 SingleThreadExecutor

4.3.1 Executors类中源码

•  

4.3.2 详解

 

4.4 ScheduledThreadpool

4.4.1 Executors中源码

4.4.2 详解

 

4.5 WorkStealingPool

4.5.1 Executors类中源码

•     /**
       *
       */
      public static ExecutorService newWorkStealingPool() {
          return new ForkJoinPool
              (Runtime.getRuntime().availableProcessors(),
               ForkJoinPool.defaultForkJoinWorkerThreadFactory,
               null, true);
      }
  
      
      /**
       *
       */
      public static ExecutorService newWorkStealingPool(int parallelism) {
          return new ForkJoinPool
              (parallelism,
               ForkJoinPool.defaultForkJoinWorkerThreadFactory,
               null, true);
      }

   

4.5.2 详解

 

4.6 ForkJoinPool

4.6.1 ForkJoinPool类中源码

•     /**
       *
       */
      public ForkJoinPool() {
          this(Math.min(MAX_CAP, Runtime.getRuntime().availableProcessors()),
               defaultForkJoinWorkerThreadFactory, null, false);
      }
  
      
      /**
       *
       */
      public ForkJoinPool(int parallelism) {
          this(parallelism, defaultForkJoinWorkerThreadFactory, null, false);
      }
  
  
      /**
       *
       */
      public ForkJoinPool(int parallelism,
                          ForkJoinWorkerThreadFactory factory,
                          UncaughtExceptionHandler handler,
                          boolean asyncMode) {
          this(checkParallelism(parallelism),
               checkFactory(factory),
               handler,
               asyncMode ? FIFO_QUEUE : LIFO_QUEUE,
               "ForkJoinPool-" + nextPoolId() + "-worker-");
          checkPermission();
      }
  
      
      /**
       *
       */
      private ForkJoinPool(int parallelism,
                           ForkJoinWorkerThreadFactory factory,
                           UncaughtExceptionHandler handler,
                           int mode,
                           String workerNamePrefix) {
          this.workerNamePrefix = workerNamePrefix;
          this.factory = factory;
          this.ueh = handler;
          this.config = (parallelism & SMASK) | mode;
          long np = (long)(-parallelism); // offset ctl counts
          this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
      }
  
  
      

   

4.6.2 详解