线程池的分析

什么是线程池？

为什么会有线程池这个东西存在呢？其实原因跟其他池化技术是一样的，都是由于创建对象、连接、线程等操作时是比较“重”的，耗时的，高成本的。针对与这种场景，我们都会采用能复用就复用，而不是每次都要重新的去创建一遍，那么在性能的提升、资源的利用率上，都能获得非常理想的效果。

线程池状态

线程池状态转换图

• 从前面每个状态对应的数值能得到：RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
• 状态转换是由低到高的（-1 < 0 < 1 < 2 < 3）。

画一张状态图

所有任务的调度都是由execute方法完成的，这部分完成的工作是：检查现在线程池的运行状态、运行线程数、运行策略，决定接下来执行的流程，是直接申请线程执行，或是缓冲到队列中执行，亦或是直接拒绝该任务

首先检测线程池运行状态，如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。

如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务。

如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。

如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。

如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

 public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();

        //获取代表线程池状态和线程数量的整数
        int c = ctl.get();
        //工作线程数<核心线程数
        if (workerCountOf(c) < corePoolSize) {
            //创建核心线程执行任务，成功就返回
            if (addWorker(command, true))
                return;
            //创建核心线程数失败，重新获取ctl
            c = ctl.get();
        }
    //确认线程池是Running状态，将任务添加到阻塞队列中
        if (isRunning(c) && workQueue.offer(command)) {
        //再次获取ctl
            int recheck = ctl.get();
        //再次判断是否是RUNNING，如果不是RUNNING状态，移除任务
            if (! isRunning(recheck) && remove(command))
            //拒绝策略
                reject(command);
  //如果线程池处在RUNNING状态，但是工作线程为0
        //线程池中allowCoreThreadTimeOut参数允许核心线程和非核心线程超时时间一样
            else if (workerCountOf(recheck) == 0)
            //阻塞队列有任务但是没有工作线程，添加一个任务为空的工作线程处理阻塞队列中的任务
                addWorker(null, false);
        }
    //线程池是Running状态，阻塞队列已满，创建非核心线程处理任务
        else if (!addWorker(command, false))
    //if语句中的非核心线程创建失败，说明线程池已经达到最大线程数，拒绝策略
            reject(command);
    }

Worker线程增加
增加线程是通过线程池中的addWorker方法，该方法的功能就是增加一个线程，该方法不考虑线程池是在哪个阶段增加的该线程，这个分配线程的策略是在上个步骤完成的，该步骤仅仅完成增加线程，并使它运行，最后返回是否成功这个结果。addWorker方法有两个参数：firstTask、core。firstTask参数用于指定新增的线程执行的第一个任务，该参数可以为空；core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize。

addwork 源码分析

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
       // rs >= SHUTDOWN，表明线程状态不是RUNNING
        //rs == SHUTDOWN，表明线程池是SHUTDOWN状态，外层取反，表明只能是STOP以上更高的状态，这是不需要添加线程处理任务。
        //firstTask == null，表明任务为空。外层取反，表示任务不为空，SHUTDOWN状态以上不接收新任务，创建工作线程失败
        //阻塞队列不为空，取反，为空，大于等于SHUDOWN状态，证明阻塞队列中没有任务处理，不会创建新线程处理任务
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
            //创建工作线程失败
                return false;

            for (;;) {
            //获取工作线程个数
                int wc = workerCountOf(c);
            //当前线程数已经大于线程池最大容量，不去创建
            //判断工作线程数是否超过核心线程数或者最大线程数
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
            //使用CAS方法将工作线程数+1
                if (compareAndIncrementWorkerCount(c))
                //跳出外层的for循环
                    break retry;
                c = ctl.get();  // Re-read ctl
            //判断状态是否变化
                if (runStateOf(c) != rs)
                    //继续执行外层的for循环
                continue retry;
            // 线程池状态没变继续执行内侧循环
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
    //Worker w就是工作线程
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
            //获取线程池的全局锁，避免该工作线程w添加任务时，其他线程干掉了线程池，干掉线程池前需要先获取这个锁
                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());
//RUNNING状态
                //SHUTDOWN状态，创建空任务工作线程，处理阻塞队列中的任务
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            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;
    }

看下这个work内容

  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;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            禁止中断，直到运行Worker
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker. */
        真正的run方法
        public void run() {
            runWorker(this);
        }

线程启动后实际上调用的就是这个run方法走的 是runworker方法

runWorker方法
runWorker方法是线程池的核心：
1.while循环不断地通过getTask()方法获取任务。
2.getTask()方法从阻塞队列中取任务。
3.如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态。
4.执行任务。
5.如果getTask结果为null则跳出循环，执行processWorkerExit()方法，销毁线程。

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        //1. 任务不为空，执行任务
        //2. 如果任务为空，通过getTask方法从阻塞队列中获取任务

        getTask 如果当前队列为空就会在这阻塞，当有新任务进入的时候
        就会解锁让这个循环继续执行，这个队列有超时机制
        while (task != null || (task = getTask()) != null) {
            w.lock();
            //获取当前状态，是否大于等于STOP.
            if ((runStateAtLeast(ctl.get(), STOP) ||
                    (Thread.interrupted() &&
                    runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                //执行任务前的操作
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    //开始执行任务
                    task.run();
                } catch (RuntimeException x) {
                    thrown = x; throw x;
                } catch (Error x) {
                    thrown = x; throw x;
                } catch (Throwable x) {
                    thrown = x; throw new Error(x);
                } finally {
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        //线程执行完毕的后续处理
        processWorkerExit(w, completedAbruptly);
    }
}

看下getTask，我认为这个是这个方法比较重要的方法

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        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);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                这个take如果队列没数据就在这挂起，队列的offer方法将这个地方唤醒
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

有启动就有关闭，我们看下shutdown和shutdownNow

  public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        这把锁，如果正在添加任务会添加任务完再shutdown
        如果没有 添加完会通过状态取消掉任务
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);1. 把线程池的状态设置为 SHUTDOWN
            interruptIdleWorkers();2. 把空闲的工作线程置为中断
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

看下把空闲线程关闭的方法

private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                通过这个方法来判断是否空闲线程
                没有被中断，且 能拿到锁
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        将空闲线程interrupt
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

再看下shutdownNow

   public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP); 将线程池置为stop
            interruptWorkers();
            tasks = drainQueue(); 干掉所有的任务，循环remove
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

   private void interruptWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers)
                直接在work里面干掉所有的工作线程，当然已经执行的任务没执行完那它干不掉
                w.interruptIfStarted();
        } finally {
            mainLock.unlock();
        }
    }

举个demo吧，说说实际项目中运用

其实运用最多的就是单一线程池，还有默认线程池，还有OKhttp中的线程池，我们挨个看下

单一线程池这个运用在一个项目中，当时比较头痛于大量线程并发处理问题，有些场景是有时序关系的

    public ExecutorService getThread() {
        if (mThread == null) {
            synchronized (this) {
                if (mThread == null) {
                    mThread = Executors.newSingleThreadExecutor(new ThreadFactory() {
                        @Override
                        public Thread newThread(Runnable r) {
                            return new Thread(r, "single-thread");
                        }
                    });
                }
            }
        }
        return mThread;
    }


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

这是一个单一子线程的例子，最大线程数是1，核心线程数也是1

默认线程池就不看了，这东西因项目而定，看下OKHTTP的线程池

  public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<>(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
  }

核心线程数为0，最大线程数理论上是无限的 

SynchronousQueue 是一个没有缓冲数的队列，这个线程池的特点就是当我们执行一个新任务时候就会开一个新线程进行执行不会等待