java源码学习-线程池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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize：int类型，核心线程数量。指的是哪怕没有正在执行的task，也不会结束的线程
allowCoreThreadTimeOut：boolean类型，是否允许核心线程超时。这个不是构造方法里面的，放在这里也是为了参数说明。默认false，为true时代表允许核心线程也可以结束线程
maximumPoolSize ：int类型，最大线程数。指的是超过这个数量则不会创建新的线程。新的任务会被添加到workQueue中。
workQueue：BlockingQueue<Runnable>类型，阻塞的链表结构，保存任务队列。一个线程池中只会有一个任务队列，超过一定数量时会调用handler进行处理。
keepAliveTime：int类型，允许存活时间。指的是如果线程执行完了所有的task任务，超过这个时间未获取到新的任务则会结束线程。
threadFactory：执行器创建新线程时要使用的工厂。利用工厂模式创建新的线程，不同工厂提供的生成策略不一样。Executors中提供了两种实现方式DefaultThreadFactory、PrivilegedThreadFactory
handler：拒绝策略。当任务数量超过workQueue中所允许的最大数量后所执行的策略。            

 

二、调用流程

我们先创建一个简单的默认线程池，核心线程数为1，最大线程数为2。

ThreadPoolExecutor executor = (new ThreadPoolExecutor(1, 2,
                5L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>()
        ));

1、执行起点就是简单的execute

 executor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("bbb");
            }
        });

2、execute方法

 public void execute(Runnable command) {
        if (command == null)
      	...
        int c = ctl.get();//这是一个记录当前状态的值，前3位记录当前线程池运行状态，后面记录线程数量
        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)
            //如果正在运行中，并且正在执行的线程数量为0，则创建新的Worker。为创建第一个线程时
                addWorker(null, false);
        }
        else if (!addWorker(command, false))//走正常添加流程
            reject(command);
    }

总体上来说，就是说当前线程数量为0时，直接执行任务。

否则，会把任务加入到workQueue当中，根据条件判断是否需要创建新的worker。、

要注意的是，调用addWorker并不是一定能够创建新的Worker

3、addWorker方法

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
           ...
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
//core一般都是false，true的情况下也会在外面判断是否小于maximumPoolSize。所以这里认为线程数量大于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。worker为线程的代理类，控制线程的调度处理。
            w = new Worker(firstTask);
            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();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();//Thread线程启动
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

4、Worker类

这是一个线程代理类，实现了Runnable接口，并把自身对象传递给Thread，所以线程启动时调用的是Worker的run方法。而worker在run方法中执行一些调度逻辑，从而实现了task依次执行。

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) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);//把自身传递给thread
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
            runWorker(this);//线程启动时则会执行Runnable的run方法，就会调到这里。
        }
	...
}

5、runWorker方法

该方法负责线程执行的整个流程。

其实就是负责通过getTask方法获取Runnable的任务，然后执行。如果执行完成，则会调用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 {
            while (task != null || (task = getTask()) != null) {
                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();
                    } 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);
        }
    }

 

6、getTask方法

该方法负责调度，就好像一个包工头。每个工人（worker）过来向包工头（getTask）请求任务，如果有就返回任务，然后工人就拿着任务回去干活了。

如果没有任务，则有两种策略。

第一种：包工头说你给我等着，所以工人就阻塞在这里了。一直等到来了新的任务，工人就开开心心的拿回去继续干活了。

第二种：包工头说你等几分钟，如果有活你就拿回去干，没有的话你就回去下班吧。

对应的代码段为：

 Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :对应的第二种策略，等待keepAliveTime时间，超时则返回null。

当然如果返回了null不会立马返回，会设置timedOut=true，再次循环的时候返回null跳出。

workQueue.take();对应第一种策略，一直等到有任务才返回runnable对象。

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 {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

7、processWorkerExit方法

把Worker从workers中移除，结束

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

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }

        tryTerminate();

        int c = ctl.get();
        if (runStateLessThan(c, STOP)) {
            if (!completedAbruptly) {
                int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
                if (min == 0 && ! workQueue.isEmpty())
                    min = 1;
                if (workerCountOf(c) >= min)
                    return; // replacement not needed
            }
            addWorker(null, false);//这里是补偿策略，一般是走不到这里的。上面就直接return了
        }
    }

三、总结

总体来说，就是分了几个线程去执行task任务，但是都是向同一个Block队列请求任务。如果没有任务时，线程则会根据不同的策略，有的线程结束，有的线程block住等待任务。由于线程时block的，所以也不会占用cpu资源。

这里有一点需要注意的就是，比如核心线程数为3，那么不是说永远维持三个用不结束的线程，而是说永远都维持有至少三个正在运行的线程。比如三个线程的基础上，又加入了一个线程。那么前面的三个线程中首个执行完task后也是会结束的。

另外由于需要保证最多线程数量，以及task不会被重复执行，所以getTask、addWorker以及一些线程池状态都加了锁。则会降低一定的效率。

总结一些：

线程池优势：

1、实现Thread的复用，避免重复创建太多Thread对象。

2、线程池来维持一定数量的线程运行，避免同一时间过多同时运行的线程造成效率下降。（就好比在楼道里发生紧急撤离时，排队按秩序离开的效率，要比无秩序快的多）

 

线程池劣势：

1、由于需要对象来维持这一秩序，所以会造成额外的内存消耗。

2、一个线程调度执行几个task，效率会降低。

3、各种锁的存在，会降低性能。