线程池原理及源码分析

创建线程池方式

ExecutorService executorService = Executors.newCachedThreadPool();//快
        ExecutorService executorService1 = Executors.newFixedThreadPool(10);//第二快
        ExecutorService executorService2 = Executors.newSingleThreadExecutor();//慢

实际上他们都是new的下面这个类

public ThreadPoolExecutor(int corePoolSize,//核心线程数
                              int maximumPoolSize,//最大线程数，cpu密集型（复杂的运算）设置为cpu核心数，io密集型设置为cpu核心数2倍
                              long keepAliveTime,//非核心线程数过期时间
                              TimeUnit unit,//时间单位
                              BlockingQueue<Runnable> workQueue,//队列
                              ThreadFactory threadFactory,//线程工厂
                              RejectedExecutionHandler handler//拒绝策略)

三种创建线程池对应的参数

newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
//0核心线程数，特别多非核心线程数，1分钟过期。队列中只能存一个任务，什么时候取出什么时候继续存

newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
//只有核心线程数，链表的队列可以无限装

newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
//就一个线程再执行，链表的队列可以无限装

执行流程

1、先抢占核心线程数

2、核心线程数满了之后进入队列

3、队列满了启用非核心线程（最大线程-核心线程）

4、都满了执行拒绝策略

常用队列

1、SynchronousQueue：队列中只能存一个任务，什么时候取出什么时候继续存

2、LinkedBlockingQueue：链表的队列可以无限装

3、ArrayBlockingQueue：装规定大小的队列

拒绝策略

1、CallerRunsPolicy：不抛弃一场，调用线程池的线程帮忙执行。比如是我的main方法调用的，那么main方法的线程也协助执行任务

2、AbortPolicy：抛出异常，丢弃任务

3、DiscardPolicy：丢弃任务，不报异常（丢后进来的任务）

4、Discard01destPolicy：丢弃任务，不报异常（丢先进来的任务）

线程池体系结构

Execytor 线程池顶级接口定义了线程池的最基本方法

ExecutorService 定义常用方法

ThreadPoolExecutor 线程池核心实现类

ScheduledThreadPoolExecutor

Executors 线程池工具类

源码分析

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();//如果没有参数直接报空指针异常
        /*
         * Proceed in 3 steps:
         *
         * 1. 如果运行的线程少于 corePoolSize，请尝试使用给定命令作为其第一个任务启动
         *一个新线程。对 addWorker 的调用以原子方式检查 runState 和 workerCount，因此通过返回false 来防止在不应该添加线程时添加线程的错误警报。
         *
         * 2. 如果一个任务可以成功排队，那么我们仍然需要仔细检查我们是否应该添加一个线程（因为现有的线程自上次检查后就死了）或者池在进入此方法后关闭。因此，我们重新检查状态，如果有必要，如果停止排队，则回滚，或者如果没有，则启动一个新线程。
         *
         * 3. 如果我们不能排队任务，那么我们尝试添加一个新线程。如果它失败了，我们知道我们已经关闭或饱和，因此拒绝任务。
         */
        int c = ctl.get();

        //如果当前线程数小于核心线程数
        if (workerCountOf(c) < corePoolSize) {

            //创建一个worker
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //有线程运行，向队列中添加并且添加成功
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //对线程池状态重新检查，如果发现线程池被关闭了则执行抛弃策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //添加非核心线程失败了
        else if (!addWorker(command, false))
            reject(command);
    }

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // 检查队列是否为空和线程池状态
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {

                //检查worker数量
                int wc = workerCountOf(c);

                //线程数大于容量或者（如果是核心）大于核心线程数（如果非核心）大于最大池大小
                if (wc >= CAPACITY ||
 
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {

            //创建一个worker
            w = new Worker(firstTask);
 
            //worker线程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();

                        //worker添加到set集合
                        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;
    }

处理核心线程

private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted

            //递减 ctl 的 workerCount 字段。这仅在线程突然终止时调用（参见 processWorkerExit）。其他减量在 getTask 中执行。
            decrementWorkerCount();

        //加一个可重入锁（该线程可重复进入）
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {

            //已完成任务数+该线程完成任务数
            completedTaskCount += w.completedTasks;

             //set集合中删掉这个线程
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }

        tryTerminate();

        int c = ctl.get();

        //线程池停了
        if (runStateLessThan(c, STOP)) {

            //不是突然停的
            if (!completedAbruptly) {

                //核心线程是否支持过期
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;

                // 核心线程支持过期并且队列任务为0
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;

                 //核心线程如果支持过期：当前线程大于等于1个。核心线程如果不支持过期：当前线程大于等于核心线程数
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }

            //是突然停的：添加线程，不是突然停的，并且线程数少：添加线程
            addWorker(null, false);
        }
    }

删除非核心线程，在获取任务时

private Runnable getTask() {
        boolean timedOut = false; // 判断最后一次获取是否超时

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

           
            //获取线程数
            int wc = workerCountOf(c);

            // 允许核心线程超时 || 线程数大于核心线程数（有非核心线程）
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            //（（线程数是否大于最大线程数 || （timed && 最后一次获取是否超时）） && （线程数大于1，任务队列为空）
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {

                  //减线程后退出
                if (compareAndDecrementWorkerCount(c))
 
                    return null;
                continue;
            }

            try {
                Runnable r = timed ?

                    //如果时间超时为0的话返回为null
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;

                //最后一次获取超时
                timedOut = true;
              
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }