线程池核心源码阅读

使用线程池可以避免多次创建和销毁线程所带来的资源消耗。使用线程池可以进行统一的分配、调优和监控。

线程池参数

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

corePoolSize
核心线程数，核心线程创建后不会回收线程，始终保持
maximumPoolSize
最大线程数，当前线程池最大线程容量，相当于corePoolSize+临时线程的数量
keepAliveTime 空闲线程最大存活时间

TimeUnit时间单位
BlockingQueue 阻塞工作队列：用来存储等待执行的任务；
threadFactory 线程工厂，用来创建线程，根据业务可以设置不通线程名来快速定位问题
handler 拒绝策略，当线程池满了时，执行的策略，常见的有：

AbortPolicy - 直接抛出RejectedExecutionException异常

DiscardPolicy - 直接丢弃任务

DiscardOldestPolicy - 丢弃最早的任务，然后重新执行线程池execute

CallerRunsPolicy - 除非线程池已经关闭，否则直接执行任务

二、线程池分类

FixedThreadPool线程池

线程数固定的线程池，使用了一个无限容量的LinkedBlockingQueue队列来存储任务

  public static ExecutorService newFixedThreadPool(int nThreads) {
      return new ThreadPoolExecutor(nThreads, nThreads,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>());
  }

CachedThreadPool线程池

线程数根据任务动态调整的线程池，由于线程数可以无限增加，并不需要使用队列来存储任务，所

以用了一个无容量的SynchronousQueue队列来存储，它的作用是对任务进行中转和传递，效率高。

  public static ExecutorService newCachedThreadPool() {
      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                    60L, TimeUnit.SECONDS,
                                    new SynchronousQueue<Runnable>());
  }

ScheduledThreadPool线程池

能实现定时、周期性任务的线程池，由于支持定时任务，所以使用的是支持延时的DelayedWorkQueue延时队列，内部任务根据延迟时间先后排列。

  public ScheduledThreadPoolExecutor(int corePoolSize) {
      super(corePoolSize, Integer.MAX_VALUE,
            DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
            new DelayedWorkQueue());
  }

SingleThreadExecutor线程池

单线程化的线程池，阻塞队列是LinkedBlockingQueue， 适用于串行执行任务的场景，将任务按顺序执行。

  public static ExecutorService newSingleThreadExecutor() {
      return new FinalizableDelegatedExecutorService
          (new ThreadPoolExecutor(1, 1,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>()));
  }

三、线程池管理线程

Work类

当ThreadPoolExecutor线程池，通过exeute()方法执行1个线程任务时，会调用addWorker()方法创建一个Woker工作线程对象。并且，创建好的Worker工作线程对象，会被添加到一个HashSet<Worker> workders工作线程集合，统一由线程池进行管理。

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    /**
     * This class will never be serialized, but we provide a
     * serialVersionUID to suppress a javac warning.
     */
    private static final long serialVersionUID = 6138294804551838833L;

    /** Thread this worker is running in.  Null if factory fails. */
    final Thread thread;												
    /** Initial task to run.  Possibly null. */
    Runnable firstTask;												
    /** Per-thread task counter */
    volatile long completedTasks;										
     */
    Worker(Runnable firstTask) {
        setState(-1);
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    /** Delegates main run loop to outer runWorker  */
    public void run() {
        runWorker(this);
    }

当Worker工作线程，在第一次执行完成线程任务后，这个Worker工作线程并不会销毁，而是会以循环的方式，通过线程池的getTask()方法，获取阻塞工作队列中新的Runnable线程任务，并通过当前Worker工作线程中所绑定Thread线程，完成新线程任务的执行，从而实现了线程池的中Thread线程的重复使用。

execute()方法

execute()方法执行流程：

1、获取线程池的状态和工作线程数

2.判断当前线程池中的工作线程数

3.如果，工作线程的数量小于核心线程数，则通过addWorker()方法，创建新的Worker工作线程，并添加至workers工作线程集合

4.如果，工作线程的数量大于核心线程数，并且线程池处于RUNNING状态，那么，线程池会将Runnable类型的线程任务，缓存至workQueue阻塞工作队列，等待某个空闲工作线程获取并执行该任务；

5.如果，workQueue工作队列缓存线程任务失败，代表工作队列已满。那么，线程池会重新通过addWorker()方法，尝试创建新的工作线程；

6.这次创建时，会判断工作线程数是否超出最大线程数。如果没有超出，会创建新的工作线程；如果已经超出，则返回false，代表创建失败

7.如果创建失败，线程池执行拒绝策略；

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();									// 获取状态表示
        if (workerCountOf(c) < corePoolSize) {				// 1. 如果当前线程数小于核心线程数，直接新建线程执行任务
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {		// 2. 如果核心线程数已满，且是运行状态并且队列未满，添加任务至队列
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))	// 再次检查运行状态，如果不是运行状态就从队列中删除任务，删除成功后执行拒绝策略，因为此时线程池状态不是RUNNING
                reject(command);
            else if (workerCountOf(recheck) == 0)			// 如果当前线程数为 0，而我们又刚刚添加了一个任务，就新建一个空任务的线程，它会去轮询任务队列执行刚刚新增的任务
                addWorker(null, false);
        }
        else if (!addWorker(command, false))				// 添加失败，执行拒绝策略
            reject(command);
    }

addWorker()方法

addWorker()方法的作用是创建工作线程，用于执行线程任务。

private boolean addWorker(Runnable firstTask, boolean core) {
  // 创建并执行工作线程....
  boolean workerStarted = false; // 工作线程是否已经启动
  boolean workerAdded = false;   // 工作线程是否已经保存
  Worker w = null;
  try {
    // 创建新工作线程,并通过线程工厂创建Thread线程
    w = new Worker(firstTask);

    // 获取新工作线程的Thread线程对象,用于启动真正的线程
    final Thread t = w.thread;
    if (t != null) {

      // 获取线程池的ReentrantLock主锁对象
      // 确保在添加和启动线程时的同步与安全
      final ReentrantLock mainLock = this.mainLock;
      mainLock.lock();
      try {
        // 检查线程池状态
        int rs = runStateOf(ctl.get());
        if (rs < SHUTDOWN ||
            (rs == SHUTDOWN && firstTask == null)) {

          // 检查Thread线程对象的状态是否已经处于启动状态
          if (t.isAlive()) 
            throw new IllegalThreadStateException();

          // 保存工作线程
          workers.add(w);

          // 记录线程池曾经达到过的最大工作线程数量
          int s = workers.size();
          if (s > largestPoolSize)
            largestPoolSize = s;
          workerAdded = true;
        }
      } finally {
        mainLock.unlock();
      }

      // 添加工作线程后，正式启动线程
      if (workerAdded) {
        t.start();
        workerStarted = true;
      }
    }
  } finally {
    if (! workerStarted)
      addWorkerFailed(w);
  }

  // 返回线程启动状态
  return workerStarted;
}