ThreadPoolExecutor是怎样执行任务的

      return false;
      //内层循环
            for (;;) {
                int wc = workerCountOf(c);
                //2. 当线程池中的线程数量达到上限以后，返回false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //3. 如果线程数量能够增加，则break到retry标签，（跳过内外层两层循环），继续往下执行。
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // 重新读取 ctl 的值
                //4. 如果线程池的状态发生了改变，就continue到retry标签，重新执行外层循环。
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
                //5. 如果是因为工作线程数量的变化导致CAS操作失败，那么继续执行内层循环
            }
        }
        //6. 开始添加Worker的逻辑
        //标记新添加的工作线程是否启动    
        boolean workerStarted = false;
        //标记新的线程是否添加成功
        boolean workerAdded = false;
        //工作线程
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
               //说明线程工厂成功的创建了一个线程
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    //获取锁以后再次检查
                    int rs = runStateOf(ctl.get());
        //如果线程池状态是RUNNING 或 线程池状态是SHUTDOWN 并且fistTask==null
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // 表示线程已经被启动过了，则抛出异常
                            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 {
            //最后判断启动任务如果失败，就把任务从工作集中移除，减小最大线程数largestPoolSize
            //并试着终止线程池
            if (! workerStarted)
                addWorkerFailed(w);
        }
        //返回任务是否成功启动
        return workerStarted;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
上面的注释已经很清楚了，这里再梳理一下流程。

如果线程池已经已经STOP,或者TIDYING，或者TERMINATED，并且firstTask == null，并且队列并不为空的情况下，就直接返回false,不再添加新的线程。
当线程池中的线程数量达到上限以后，返回false；
如果线程数量能够增加，则break到retry标签，（跳过内外层两层循环），继续往下执行；
如果线程池的状态发生了改变，就continue到retry标签，重新执行外层循环；
如果是因为工作线程数量的变化导致CAS操作失败，那么继续执行内层循环；
开始添加Worker的逻辑；
我们看一下Worker这个类的精简版
 private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {

        //执行当前任务的线程
        final Thread thread;
        //要执行的任务，可能为null
        Runnable firstTask;
        //每个线程的任务计数器，用来标记当前线程执行了多少个任务
        /** Per-thread task counter */
        volatile long completedTasks;

        //构造函数
       Worker(Runnable firstTask) {
            ...
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        //run方法调用了ThreadPoolExecutor的runWorker方法
        public void run() {
            runWorker(this);
        }
        
        ...
        //省略其他方法
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
看一下runWorker方法的主要逻辑。这个方法是ThreadPoolExecutor类里面的方法。
 final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); //允许中断
        boolean completedAbruptly = true;
        try {
        //如果task不为null或者从队列中取出的任务不为null
        //1. 从队列中取出任务可能会导致阻塞。
            while (task != null || (task = getTask()) != null) {
                w.lock();
                //2. 中断线程
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                   //3. 执行任务
                        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);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
getTask() 从队列中获取任务。
在适当的时候中断wt；
如果线程池处于STOP,TIDYING,TERMINATED状态并且wt没有被中断，则中断 wr 。
如果当前线程被中断了并且线程池处于STOP,TIDYING,TERMINATED状态并且wt没有被中断，则中断 wr 。
执行任务。
我们看一下getTask()这个方法
/**
     * 执行阻塞或定时等待任务，具体取决于当前配置设置，或者当前worker由于以下原因必须停止的时候返回null；
     * 1. worker的数量大于maximumPoolSize 
     * 2. 线程池停止了（STOP）
     * 3. 线程池 shutdown 了并且任务队列empty
     * 4. worker在等待任务的时候超时（非核心线程池超过存活时间，或者核心线程池超过存活时间）， 
     *   超过存活时间的worker会终止，如果任务队列不为空，则当前线程不是线程池中最后一个线程
     *
     * @return 返回一个任务；或者当 worker必须退出的时候返回null，在这种情况下，workerCount 会减少。
     */
    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

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

            // 在必要的条件下检查任务队列是否为empty
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
     //减少线程池中线程数量，返回null
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                //获取任务并返回，如果是定时等待任务，则使用poll方法，否则使用take方法
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    //返回获取的任务
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
逻辑已经很清楚了，不再细究。

另外还有两个方法注意一下

我们可以重写这个方法，在执行每个任务之前做一些操作。

protected void beforeExecute(Thread t, Runnable r) { }
1
我们可以重写这个方法，在执行每个任务之后做一些操作。

protected void afterExecute(Runnable r, Throwable t) { }
1
先分析到这里，以后有新的理解和体会，再继续写。

现在总结一下 线程池执行任务的流程：
1.如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务；
2.如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务缓存队列已满），则会尝试创建新的线程去执行这个任务；
3.如果当前线程池中的线程数目达到maximumPoolSize，则会采取任务拒绝策略进行处理；

结尾：若有不正之处请多多谅解，并欢迎批评指正。
原文：https://blog.csdn.net/leilifengxingmw/article/details/79533006