线程池ThreadPoolExecutor

线程池的生命周期

 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

 ThreadPoolExecutor使用一个ctl变量代表两个信息，线程池的运行状态 (runState) 和 线程池内有效线程的数量 (workerCount)，高三位表示状态。

workerCount：线程池内有效线程的数量，工作线程允许开始，不允许停止，使用ctl的低29位表示

runState：线程的生命周期，是有序的随时间递增，也就是状态不可逆的。

    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;
 
    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;
 
    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

 

 任务调度

execute

  public void execute(Runnable command) {
//判断任务是否为空
        if (command == null)
            throw new NullPointerException();
//获取当前工作线程数量和线程状态
        int c = ctl.get();
//如果工作线程数小于核心线程数
        if (workerCountOf(c) < corePoolSize) {
//增加一个核心线程去执行任务
//增加成功结束
            if (addWorker(command, true))
                return;
//增加失败，再次获取当前线程池的工作线程数量和线程状态
            c = ctl.get();
        }
//如果当前线程池正在运行
//将任务放入阻塞队列
        if (isRunning(c) && workQueue.offer(command)) {
//插入成功★
//再次获取当前线程池的工作线程数量和线程状态
            int recheck = ctl.get();
//此时（并发情况）线程池非Running状态
//将任务移除阻塞队列
            if (! isRunning(recheck) && remove(command))
//移除成功，执行抛弃策略
                reject(command);
//移除失败，则判断当前的工作线程数是否为0
            else if (workerCountOf(recheck) == 0)
//为0则增加一个空工作线程，（去执行★之前插入成功的任务）
                addWorker(null, false);
        }
//创建一个非核心线程去执行任务
        else if (!addWorker(command, false))
//创建失败，执行拒绝策略
            reject(command);
    }

 submit

submit传入任务以及其返回值类型，如果任务是Runnable的话上会将任务包装成Callable任务也就是RunnableFuture，然后再丢给execute去执行。

阻塞队列

线程池使用阻塞队列将要执行的任务与线程分开，用生产者和消费者模型实现。

当任务数量超过核心线程数，后续任务就会放入阻塞队列中进行排队。

因为实现了BlockingQueue所以都是线程安全的。

任务拒绝

当线程池的缓存队列已满，线程数也达到了maximumPoolSize 时，再新增任务就会触发拒绝策略。

拒绝策略收到三个参数影响：corePoolSize 、maximumPoolSize 、workQueue 。

当任务提交后，如果没达到核心线程数，则会直接创建核心线程运行，如果达到了核心线程数则会放入队列中等待，当任务数大于workQueue.size+maximumPoolSize则触发拒绝策略。

常用线程池

newCachedThreadPool

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

核心参数

核心线程数：0

最大线程数：Integer.MAX_VALUE

线程存活时间：60s

阻塞队列：SynchronousQueue(同步队列)

分析：因为没有核心线程，所以任务进来都会放入同步队列中，然后创建工作线程去执行，由于没有核心线程，最大线程数又是一个很大的值，基本意味着线程数量无限大，线程池中只要没有空闲线程就会创建新的去执行任务。线程池的线程一旦超过60s就会被销毁。所以当没有任务的时候，几乎不会占用什么资源。

场景：适合任务量大但是时间很短的场景

newFixedThreadPool

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

核心参数

核心线程数=最大线程数

最大线程数=核心线程数

线程存活时间：0

阻塞队列：LinkedBlockingQueue(链表阻塞队列)

分析：由于核心线程数=最大线程数，所以线程池无空闲核心线程则会进入阻塞队列，并且线程池中的线程都是核心线程也不需要销毁。同时使用了LinkedBlockingQueue，队列长度Integer.MAX_VALUE。

场景：适合任务量比较固定但耗时长的任务

newSingleThreadPool

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

核心参数

核心线程数=1

最大线程数=1

线程存活时间：0

阻塞队列：LinkedBlockingQueue(链表阻塞队列)

分析：只有一个线程的线程池，当唯一的线程发生异常会重启一个线程代替执行，也就是约等于以单线程的形式进行工作。

场景：适合需要顺序执行任务的场景

newScheduledThreadPool

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

核心参数

核心线程数=可指定

最大线程数=Integer.MAX_VALUE

线程存活时间：0

阻塞队列：DelayedWorkQueue（优先级工作队列）

分析：核心线程数是固定的，但非核心是基本没有限制的，因为空闲时间为0，所以一旦非核心线程执行完就会被回收。由于使用的是DelayedWorkQueue，任务会按照顺序执行。

场景：适合执行定时任务和固定周期的重复任务

newWorkStealingPool

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

核心参数：无

分析：Java8新增的创建线程方式创建时不设置任何参数的话，就会以当前机器的cpu个数为线程个数，此线程池会并行处理任务，不能保证执行顺序。可以充分利用多cpu，多核cpu的优势，把一个任务拆分成多个“小任务”分发到不同的cpu核心上执行，执行完后再把结果收集到一起返回。

场景：需要合理使用cpu资源的场景，且任务耗时很大且无需顺序执行的场景。

ThreadPoolExecutor

ThreadPoolExecutor的核心池线程的数量该如何设置？

CPU密集型：cpu core+1

IO密集型：2cpu core

cpu core：Runtime.getRuntime().availableProcessors()