Java并发编程之ThreadPoolExecutor线程池源码剖析

  我们开始从 ThreadPoolExecutor 可以做什么来说起，然后进行源码剖析。
  ThreadPoolExecutor 的初始化方法为：

    public ThreadPoolExecutorLocal(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) { . . . }

  1、第一个参数为corePoolSize：即线程池的核心数量，比如是 10 ，那么当线程生成了1个线程时，则会保留这个线程。因为未超过10个，所以最多保留10个核心线程
  2、maximumPoolSize：最大线程数，即当核心线程都在运行，且 workQueue 已满，则会增加临时线程来执行任务，核心线程+临时线程最大为 maximumPoolSize。
  3、keepAliveTime，unit：临时线程的保留时间，比如10s，则超过10s，临时线程就会被销毁（其实就是执行完毕，自动结束）
  4、workQueue：runnable存放的queue，线程会从此 queue 中来取runnable来执行。
  5、threadFactory：即创建线程的 Factory ，此会传入一个runnable，然后让你返回一个Thread，其实就是让你调用Thread的
Thread(Runnable  runnable, String threadName)
即让你给thread来起一个名字
  6、handler：拒绝执行的handler，当现在线程处于最大线程数，且queue也满了的时候，则线程池则会拒绝执行，此时会回调这个方法，告诉你runnable被拒绝执行了。

  eg：

        ThreadPoolExecutorLocal threadPoolExecutorLocal = new ThreadPoolExecutorLocal(
                10,
                25,
                10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(20),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        return new Thread(r, "threadPoolExecutorLocal-Thread");
                    }
                },
                new RejectedExecutionHandler() {
                    @Override
                    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                        System.out.println(" runnable 被拒绝执行了" );
                    }
                });

此线程池核心线程为 10 个，最大为25个，超过的线程最多保留10s，queue的大小为20个，创建的Thread的名称固定为 threadPoolExecutorLocal-Thread ，并且也实现了 RejectedExecutionHandler 。

 

一、关于线程池的一些问题：
  在分析源码之前，我们先上几个问题：
1、ThreadPoolExecutor初始就生成全部 core 的线程么
2、ThreadPoolExecutor是如何指派线程来执行的？是让指定线程wait，然后有 runnable 之后 notify 么
3、如何从 Queue 中来取？当发现没有可执行的core的时候放到 Queue 中，然后 core 在执行的的时候先从 core 的队列中取？没有就从 Queue 中来取？
4、如果超过了 Queue 的大小，是如何生成一个线程的？又如何保证这个线程在指定时候内不执行就删除？    
    
 

二、线程池源码剖析：

   1、ThreadPoolExecutor执行runnable的源码：

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

        int c = ctl.get();
        // 当 当前执行线程小于核心线程的时候，执行addWorker(command, true)，添加一个执行线程
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 如果不小于，那么添加到 workQueue 中
        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);
        }
        // 如果 workQueue 添加不进去（一般情况即queue满了），那么执行addWorker(command, false)，即添加一个执行线程
        else if (!addWorker(command, false))
            reject(command);
    }

  2、添加执行线程addWorker()的源码：

    private boolean addWorker(Runnable firstTask, boolean core) {

        log.info(" 开始addWorker core为" + core);

        retry:
        for (;;) {
            int c = ctl.get();

            int rs = runStateOf(c);

            if (rs >= SHUTDOWN &&
                    ! (rs == SHUTDOWN &&
                            firstTask == null &&
                            ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
               // core只有在这里面使用了，只去判断是否超过了core的大小或者max的大小，可以看到核心线程与临时线程其实并没有区别
                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;
        ThreadPoolExecutorLocal.Worker w = null;
        try {
            // 生成一个Worker
            w = new ThreadPoolExecutorLocal.Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    
                    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();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

 即内部的做法为：

   1、判断是否可以添加线程。
    可以看到，先去使用 core 来判断是否是核心线程或是临时线程，不过这个 core 只是用来判断数量的大小，为true则判断核心线程的数量，为false则判断最大线程数量。
  注意这个使用 for(;;)循环 与 compareAndIncrementWorkerCount 来避免并发问题，因为同一时间只有一个线程能执行通过。
   2、判断通过后添加worker：
    w = new ThreadPoolExecutorLocal.Worker(firstTask);
    判断通过后，通过runnable来添加一个worker，我们看一下worker的方法：

    private final class Worker
            extends AbstractQueuedSynchronizer
            implements Runnable
    {

        private static final long serialVersionUID = 6138294804551838833L;

        Runnable firstTask;

        volatile long completedTasks;


        // 此为初始构造方法
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        
        // run方法其实是去调用 ThreadPoolExecutor的 runWorker() 方法
        public void run() {
            runWorker(this);
        }


        protected boolean isHeldExclusively() {
            return getState() != 0;
        }
        
        // 由于继承了AbstractQueuedSynchronizer，其实Worker是一个锁，tryAcquire 与 tryRelease 方法，tryAcquire将状态由0设置为1，tryRelease将状态设置为0。
        // 此为非常简单的一个不可重入锁，同一时间只允许一个线程获取到锁。
        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

......
}

  可以看到，Worker 里面将runnable设置为自己的task，然后生成一个thread，并将这个thread的runnable置为自己。虽然真正的run方法是调用 ThreadPoolExecuto r的 runWorker() 方法，我认为其实这是一个代理模式，也就是说 Worker 也实现了runnable，这是因为我要对真正的runnable执行前，执行后做一些操作，所以我也实现了这个接口，以便对原先的runnable来做扩展。
  在 addWorker() 方法中，生成一个 Worker 后，得到其thread，然后调用其 start() 方法，里面然后调用 Worker 的run() 方法，然后调用 ThreadPoolExecuto r的 runWorker() 方法。

 

下面主要看一下 runWorker() 方法与 getTask() 方法：

    final void runWorker(ThreadPoolExecutorLocal.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 ((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);
        }
    }

    private Runnable getTask() {
        boolean timedOut = false; 

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

            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                    && (wc > 1 || workQueue.isEmpty())) {
                // 如果超时没有获取到线程，那么会在这里面通过 compareAndDecrementWorkerCount 
                // 原子方法来减少count，只有减少了，才说明通过了原子方法，可以说明这个线程确确实实可以减少 
                // ,通过这个方法保证了core的稳定性。
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {

                //  在获取task begin , 注意此线程会阻塞在 workQueue 的take()
                Runnable r = timed ?
                        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                        workQueue.take();

                if (r != null) {
                    return r;
                }

                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

  可以看到，runWorker() 方法会得到Worker里面的runnable，如果没有没有得到，则调用 getTask() 方法，我们刚开始生成一个核心线程，其Worker里面是有runnable的，如果当其执行完了，会阻塞在 getTask() 中  workQueue.take() 方法中来得到一个 runnable 。
  所以核心方法看完了，我们继续之前的 execute(Runnable) 方法，如果此时线程数量小于 core ，则生成一个worker来执行，worker会生成一个Thread，来代理执行任务，如果大于，则将 runnable 放置到queue中。如果queue中也满了，那么生成一个 addWorker(Runnable, false)，注意这时候就判断是否当前数量大于最大数量了，如果没有，就生成一个，如果大于了，那么就返回false，即执行不了。
  

三、问题回答

源码剖析完毕，我们来解答一下之前的问题  

 1、ThreadPoolExecutor初始就生成 core 的线程么？
  不是，通过源码可以看到，是初始执行execute的时候才会生成core线程。

 2、ThreadPoolExecutor是如何指派线程来执行的？是让指定线程wait，然后有 runnable 之后 notify 么
  不全是，初始执行的话里面有runnable，再次获取task的时候回阻塞在queue的take()方法中，其实也就是相当于 wait 与 notify 方法。

 3、如何从 Queue 中来取？当发现没有可执行的core的时候放到 Queue 中，然后 core 在执行的的时候先从 core 的队列中取？没有就从 Queue 中来取？
  不是，注意其实并没有分core的线程或者临时的线程，都是线程，就是看谁最后能先超时退出，也就是谁先获取到 getTask() 中的    compareAndDecrementWorkerCount(c) 方法，如果成功，则先退出，所以刚开始生成的core线程是很可能退出的。

4、如果超过了 Queue 的大小，是如何生成一个线程的？又如何保证这个线程在指定时候内不执行就删除？    
    线程在超过了core的大小之后，会再次调用addWorker()方法,生成一个worker（只要不超过max的大小）。
         在得到task的时候，即 getTask() 方法，发现大小已经超过了core，那么不会使用task的 take() 方法，即不管多长时间也等待的获取，如果此时超过了core，就是调用poll(keepAliveTime) 方法，即在指定时间内获取task，如果获取不到，则返回再进行 getTask() 方法，此时 timed && timedOut 都为true，那么如果调用
               if (compareAndDecrementWorkerCount(c))
                    return null;
       成功了，就会退出。