Java线程池源码解析

线程池

假如没有线程池，当存在较多的并发任务的时候，每执行一次任务，系统就要创建一个线程，任务完成后进行销毁，一旦并发任务过多，频繁的创建和销毁线程将会大大降低系统的效率。线程池能够对线程进行统一的分配，通过固定数量的线程来负责处理任务，避免了频繁的创建和销毁对象，使线程能够重复的利用，执行多个任务。

Java线程池的结构

Executor 最顶层接口，仅有execute方法。真正的线程池接口应该是它的子接口ExecutorService

ExecutorService接口，主要对Executor接口补充了一些方法，例如shutdown()、submit()等方法

ThreadPoolExecutor ExecutorService的默认实现，作为自定义线程池的主要类。

ScheduledExecutorService 用来解决任务重复执行的问题

ScheduledThreadPoolExecutor 继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

ThreadPoolExecutor

ThreadPoolExecutor使ExecutorService的默认实现，其功能也最为基础，通过对该类的源码解析来了解整个线程池的工作机制。

ThreadPoolExecutor最完整的构造器

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

corePoolSize 线程池中保存的线程个数，包含了空闲线程

maximumPoolSize 为线程池中最多允许线程个数

keepAliveTime 当线程产生的数量多于core时候，空闲线程在这个时间如果没有新任务将被终止

unit keepAliveTime的时间单位

workQueue 线程工作任务队列。任务被执行前保存至工作队列 常用的有ArrayBlockingQueue、LinkedBlockingQuene、priorityBlockingQuene等等

threadFactory 执行程序创建新线程时使用的工厂，默认为DefaultThreadFactory

handler 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序，主要有四种AbortPolicy、CallerRunsPolicy、DiscardOldestPolicy、DiscardPolicy

工作流程图如图

源码解析

首先，来看一下几个变量定义

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    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; }

线程池使用一个整型变量的高三位作为线程池的状态。

高位111为RUNNING 注：RUNNING为负数，最小

高位000为SHUTDOWN

高位001表示STOP

高位010表示TIDYING

高位100表示TERMINATED

workerCountOf方法用来取低29位的数值，返回线程池的线程数。

runStateOf方法则用来取高3位的数值，返回当前线程池的状态。

然后，来看用于提交任务的submit方法。

public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

该方法将Runnable进行了封装，我们这里先不考虑，先看看执行的关键方法execute();

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // workerCountOF()方法获取当前线程数量，若线程数量小于核心线程数的时候 直接进入addWorker 启动运行
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 上面是当线程数量小于core的时候，下面是针对线程数量大于core
        if (isRunning(c) && workQueue.offer(command)) { //若线程池处于运行状态，则添加到阻塞队列中
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command)) //recheck 若线程池已经关闭，就remove任务
                reject(command); //执行拒绝策略
            else if (workerCountOf(recheck) == 0) //线程池处于running状态，但是没有线程，则创建线程
                addWorker(null, false);
        }
        else if (!addWorker(command, false)) // 线程池关闭或者往workQueue提交任务失败，则reject任务
            reject(command);
    }

execute方法中可以看到，addWork作为一个创建线程并执行任务的重要方法

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

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && // rs >= SHUTDOWN 说明线程池不是running; 当线程池关闭，任务为null，workQueue不为空的时候才可以往下进行
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize)) // core为true 则超过core添加失败
                    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 {
            w = new Worker(firstTask);
            final Thread t = w.thread; //获取 worker 中的线程对象，Worker的构造方法会调用 ThreadFactory 来创建一个新的线程
            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)) { // 线程池运行或者 线程池关闭 任务为null
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w); //添加进HashSet
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;  //添加成功
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {  //如果添加成功则启动线程
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)  //启动失败则把w从works中移除
                addWorkerFailed(w);
        }
        return workerStarted;
    }

接下来看看Work类中的run方法，中的runWorker方法

public void run() {
    runWorker(this);
}
final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // 释放锁，允许中断
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) { //getTask方法不断从阻塞队列中获取任务
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                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(); //执行任务的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);
        }
    }

三种常见线程池

Executors类中为我们提供了集中常见的线程池，分别有FixedThreadPool、SingleThreadExecutor、CachedThreadPool三种

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

FixedThreadPool顾名思义 可以设置固定数量的线程池。但是LinkedBlockingQueue是无界阻塞队列，队列可存放的大小为Integer.MAX_VALUE，因此maximumPoolSize和keepAliveTime将会是个无用参数，拒绝策略也没用

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

同上，不过线程池大小仅为1

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

线程池的线程数可达到Integer.MAX_VALUE。使用SynchronousQueue作为阻塞队列。newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；