Java并发编程的艺术笔记（九）

9. Java中的线程池

1. 线程池实现原理

线程池的优点：

• 减低资源消耗
• 提高响应效率
• 提高线程的可管理性

ThreadPoolExecutor执行execute()示意图

ThreadPoolExecutor执行图

参考：《Java并发编程的艺术》

ThreadPoolExecutor的构造方法

//corePoolSize 核心线程数——核心线程不会被回收，没任务时会保持空闲状态
//maximumPoolSize 最大线程数——线程的数量等于核心线程数，并且workQueue队列已满，则继续创建线程 
//keepAliveTime 临时线程存活的时间——临时线程指非核心线程
//unit keepAliveTime的单位
//workQueue 工作阻塞队列——超出核心线程数的任务会存放在阻塞队列中，BlockingQueue底层AQS实现的
//threadFactory 线程工厂——创建线程的工厂类
//handler 拒绝策略——线程数量到达最大线程数，并且workQueue已满，则会调用拒绝策略来处理请求
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

RejectedExecutionHandler 拒绝策略

• AbortPolicy：默认拒绝策略，直接抛出异常处理
• DiscardPolicy：直接抛出不处理
• DiscardOldestPolicy：丢弃队列中最老的任务
• CallerRunsPolicy：将任务分配给当前执行的execute方法线程处理

因此Executors类中有四种线程池

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

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

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

	public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

还有一些其他的方法，基本上都是简单的封装。所以阿里爸爸不建议使用Executors来创建线程池，因为它不是那么的友好。

​ CachedThreadPool和ScheduledThreadPool最大线程数为Integer.MAX_VALUE，如果线程无限地创建，会造成OOM异常。LinkedBlockingQueue基于链表的FIFO队列，是无界的，默认大小是Integer.MAX_VALUE，因此FixedThreadPool和SingleThreadPool的阻塞队列长度为Integer.MAX_VALUE，如果此时队列被无限地堆积任务，会造成OOM异常。

参考：http://objcoding.com/2019/04/11/threadpool-initial-parameters/

2. execute方法

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
    	 /*
         * 1.如果当前的线程数小于核心线程池的大小，根据现有的线程作为第一个Worker运行的线程，
         * 新建一个Worker，addWorker自动的检查当前线程池的状态和Worker的数量，
         * 防止线程池在不能添加线程的状态下添加线程
         * 2.如果线程入队成功，然后还是要进行double-check的，因为线程池在入队之后状态是可能会发生变化的
         * 3.如果task不能入队(队列满了)，这时候尝试增加一个新线程，
         * 如果增加失败那么当前的线程池状态变化了或者线程池已经满了，然后拒绝task
         */
    
    	//当前的Worker的数量小于核心线程池大小时，新建一个Worker。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
    	//
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //recheck防止线程池状态的突变，如果突变，那么将reject线程，防止workQueue中增加新线程
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //上下两个操作都有addWorker的操作，但是如果在workQueue.offer的时候Worker变为0，
            //那么将没有Worker执行新的task，所以增加一个Worker.
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
    	//如果workQueue满了，那么这时候可能还没到线程池的maxnum，所以尝试增加一个Worker
    	//如果Worker数量到达上限，那么就拒绝此线程
        else if (!addWorker(command, false))
            reject(command);
    }

原文：https://www.jianshu.com/p/ade771d2c9c0