不怕难之线程池原理

一、线程池状态

ThreadPoolExecutor 是 JDK 中的线程池实现,这个类实现了一个线程池需要的各个方法,它实现了任务提交、线程管理、监控等等方法。

原理图:


private final AtomicIntegerctl =new AtomicInteger(ctlOf(RUNNING, 0));

    // 这里 COUNT_BITS 设置为 29(32-3),意味着前三位用于存放线程状态,后29位用于存放线程数

// 很多初学者很喜欢在自己的代码中写很多 29 这种数字,或者某个特殊的字符串,然后分布在各个地方,这是非常糟糕的

    private static final int COUNT_BITS = Integer.SIZE -3;

    // 000 11111111111111111111111111111

// 这里得到的是 29 个 1,也就是说线程池的最大线程数是 2^29-1=536870911

// 以我们现在计算机的实际情况,这个数量还是够用的

    private static final int CAPACITY  = (1 <

    // 我们说了,线程池的状态存放在高 3 位中

// 运算结果为 111跟29个0:111 00000000000000000000000000000

    private static final int RUNNING    = -1 <

    // 000 00000000000000000000000000000

    private static final int SHUTDOWN  =0 <

    // 001 00000000000000000000000000000

    private static final int STOP      =1 <

    // 010 00000000000000000000000000000

    private static final int TIDYING    =2 <

    // 011 00000000000000000000000000000

    private static final int TERMINATED =3 <

    // 将整数 c 的低 29 位修改为 0,就得到了线程池的状态

    private static int runStateOf(int c)    {return c & ~CAPACITY; }

// 将整数 c 的高 3 为修改为 0,就得到了线程池中的线程数

    private static int workerCountOf(int c)  {return c &CAPACITY; }

private static int ctlOf(int rs, int wc) {return rs | wc; }

/*

* Bit field accessors that don't require unpacking ctl.

* These depend on the bit layout and on workerCount being never negative.

*/

    private static boolean runStateLessThan(int c, int s) {

return c < s;

    }

private static boolean runStateAtLeast(int c, int s) {

return c >= s;

    }

private static boolean isRunning(int c) {

return c

    }


RUNNING:这个没什么好说的,这是最正常的状态:接受新的任务,处理等待队列中的任务

SHUTDOWN:不接受新的任务提交,但是会继续处理等待队列中的任务

STOP:不接受新的任务提交,不再处理等待队列中的任务,中断正在执行任务的线程

TIDYING:所有的任务都销毁了,workCount 为 0。线程池的状态在转换为 TIDYING 状态时,会执行钩子方法 terminated()

TERMINATED:terminated() 方法结束后,线程池的状态就会变成这个


二、Worker对象设计

private final class Worker

extends AbstractQueuedSynchronizer

implements Runnable

{

private static final long serialVersionUID =6138294804551838833L;

    // 这个是真正的线程,任务靠你啦

    final Threadthread;

    // 前面说了,这里的 Runnable 是任务。为什么叫 firstTask?因为在创建线程的时候,如果同时指定了

// 这个线程起来以后需要执行的第一个任务,那么第一个任务就是存放在这里的(线程可不止执行这一个任务)

// 当然了,也可以为 null,这样线程起来了,自己到任务队列(BlockingQueue)中取任务(getTask 方法)就行了

    RunnablefirstTask;

    // 用于存放此线程完全的任务数,注意了,这里用了 volatile,保证可见性

    volatile long completedTasks;

    // Worker 只有这一个构造方法,传入 firstTask,也可以传 null

    Worker(Runnable firstTask) {

setState(-1); // inhibit interrupts until runWorker

        this.firstTask = firstTask;

        // 调用 ThreadFactory 来创建一个新的线程

        this.thread = getThreadFactory().newThread(this);

    }

// 这里调用了外部类的 runWorker 方法

    public void run() {

runWorker(this);

    }

...// 其他几个方法没什么好看的,就是用 AQS 操作,来获取这个线程的执行权,用了独占锁

}


三、execute

public void execute(Runnable command) {

if (command ==null)

throw new NullPointerException();

    // 前面说的那个表示 “线程池状态” 和 “线程数” 的整数

    int c = ctl.get();

    // 如果当前线程数少于核心线程数,那么直接添加一个 worker 来执行任务,

// 创建一个新的线程,并把当前任务 command 作为这个线程的第一个任务(firstTask)

    if (workerCountOf(c) < corePoolSize) {

// 添加任务成功,那么就结束了。提交任务嘛,线程池已经接受了这个任务,这个方法也就可以返回了

// 至于执行的结果,到时候会包装到 FutureTask 中。

// 返回 false 代表线程池不允许提交任务

        if (addWorker(command, true))

return;

        c = ctl.get();

    }

// 到这里说明,要么当前线程数大于等于核心线程数,要么刚刚 addWorker 失败了

// 如果线程池处于 RUNNING 状态,把这个任务添加到任务队列 workQueue 中

    if (isRunning(c) && workQueue.offer(command)) {

/* 这里面说的是,如果任务进入了 workQueue,我们是否需要开启新的线程

* 因为线程数在 [0, corePoolSize) 是无条件开启新的线程

* 如果线程数已经大于等于 corePoolSize,那么将任务添加到队列中,然后进到这里

*/

        int recheck = ctl.get();

        // 如果线程池已不处于 RUNNING 状态,那么移除已经入队的这个任务,并且执行拒绝策略

        if (! isRunning(recheck) && remove(command))

reject(command);

            // 如果线程池还是 RUNNING 的,并且线程数为 0,那么开启新的线程

// 到这里,我们知道了,这块代码的真正意图是:担心任务提交到队列中了,但是线程都关闭了

        else if (workerCountOf(recheck) ==0)

addWorker(null, false);

    }

// 如果 workQueue 队列满了,那么进入到这个分支

// 以 maximumPoolSize 为界创建新的 worker,

// 如果失败,说明当前线程数已经达到 maximumPoolSize,执行拒绝策略

    else if (!addWorker(command, false))

reject(command);

}

四、添加任务

// 第一个参数是准备提交给这个线程执行的任务,之前说了,可以为 null

// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线,也就说创建这个线程的时候,

//        如果线程池中的线程总数已经达到 corePoolSize,那么不能响应这次创建线程的请求

//        如果是 false,代表使用最大线程数 maximumPoolSize 作为界线

private boolean addWorker(Runnable firstTask, boolean core) {

retry:

for (;;) {

int c = ctl.get();

        int rs = runStateOf(c);

        // 这个非常不好理解

// 如果线程池已关闭,并满足以下条件之一,那么不创建新的 worker:

// 1. 线程池状态大于 SHUTDOWN,其实也就是 STOP, TIDYING, 或 TERMINATED

// 2. firstTask != null

// 3. workQueue.isEmpty()

// 简单分析下:

// 还是状态控制的问题,当线程池处于 SHUTDOWN 的时候,不允许提交任务,但是已有的任务继续执行

// 当状态大于 SHUTDOWN 时,不允许提交任务,且中断正在执行的任务

// 多说一句:如果线程池处于 SHUTDOWN,但是 firstTask 为 null,且 workQueue 非空,那么是允许创建 worker 的

        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;

            // 如果成功,那么就是所有创建线程前的条件校验都满足了,准备创建线程执行任务了

// 这里失败的话,说明有其他线程也在尝试往线程池中创建线程

            if (compareAndIncrementWorkerCount(c))

break retry;

            // 由于有并发,重新再读取一下 ctl

            c = ctl.get();

            // 正常如果是 CAS 失败的话,进到下一个里层的for循环就可以了

// 可是如果是因为其他线程的操作,导致线程池的状态发生了变更,如有其他线程关闭了这个线程池

// 那么需要回到外层的for循环

            if (runStateOf(c) != rs)

continue retry;

            // else CAS failed due to workerCount change; retry inner loop

        }

}

/*

* 到这里,我们认为在当前这个时刻,可以开始创建线程来执行任务了,

* 因为该校验的都校验了,至于以后会发生什么,那是以后的事,至少当前是满足条件的

*/

// worker 是否已经启动

    boolean workerStarted =false;

    // 是否已将这个 worker 添加到 workers 这个 HashSet 中

    boolean workerAdded =false;

    Worker w =null;

    try {

final ReentrantLock mainLock =this.mainLock;

        // 把 firstTask 传给 worker 的构造方法

        w =new Worker(firstTask);

        // 取 worker 中的线程对象,之前说了,Worker的构造方法会调用 ThreadFactory 来创建一个新的线程

        final Thread t = w.thread;

        if (t !=null) {

// 这个是整个类的全局锁,持有这个锁才能让下面的操作“顺理成章”,

// 因为关闭一个线程池需要这个锁,至少我持有锁的期间,线程池不会被关闭

            mainLock.lock();

            try {

int c = ctl.get();

                int rs = runStateOf(c);

                // 小于 SHUTTDOWN 那就是 RUNNING,这个自不必说,是最正常的情况

// 如果等于 SHUTDOWN,前面说了,不接受新的任务,但是会继续执行等待队列中的任务

                if (rs < SHUTDOWN ||

(rs == SHUTDOWN && firstTask ==null)) {

// worker 里面的 thread 可不能是已经启动的

                    if (t.isAlive())

throw new IllegalThreadStateException();

                    // 加到 workers 这个 HashSet 中

                    workers.add(w);

                    int s = workers.size();

                    // largestPoolSize 用于记录 workers 中的个数的最大值

// 因为 workers 是不断增加减少的,通过这个值可以知道线程池的大小曾经达到的最大值

                    if (s > largestPoolSize)

largestPoolSize = s;

                    workerAdded =true;

                }

}finally {

mainLock.unlock();

            }

// 添加成功的话,启动这个线程

            if (workerAdded) {

// 启动线程

                t.start();

                workerStarted =true;

            }

}

}finally {

// 如果线程没有启动,需要做一些清理工作,如前面 workCount 加了 1,将其减掉

        if (! workerStarted)

addWorkerFailed(w);

    }

// 返回线程是否启动成功

    return workerStarted;

}

五、执行任务

// 此方法由 worker 线程启动后调用,这里用一个 while 循环来不断地从等待队列中获取任务并执行

// 前面说了,worker 在初始化的时候,可以指定 firstTask,那么第一个任务也就可以不需要从队列中获取

final void runWorker(Worker w) {

//

    Thread wt = Thread.currentThread();

    // 该线程的第一个任务(如果有的话)

    Runnable task = w.firstTask;

    w.firstTask =null;

    w.unlock(); // allow interrupts

    boolean completedAbruptly =true;

    try {

// 循环调用 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) {

// 这里不允许抛出 Throwable,所以转换为 Error

                    thrown = x; throw new Error(x);

                }finally {

// 也是一个钩子方法,将 task 和异常作为参数,留给需要的子类实现

                    afterExecute(task, thrown);

                }

}finally {

// 置空 task,准备 getTask 获取下一个任务

                task =null;

                // 累加完成的任务数

                w.completedTasks++;

                // 释放掉 worker 的独占锁

                w.unlock();

            }

}

completedAbruptly =false;

    }finally {

// 如果到这里,需要执行线程关闭:

// 1. 说明 getTask 返回 null,也就是说,这个 worker 的使命结束了,执行关闭

// 2. 任务执行过程中发生了异常

// 第一种情况,已经在代码处理了将 workCount 减 1,这个在 getTask 方法分析中会说

// 第二种情况,workCount 没有进行处理,所以需要在 processWorkerExit 中处理

// 限于篇幅,我不准备分析这个方法了,感兴趣的读者请自行分析源码

        processWorkerExit(w, completedAbruptly);

    }

}

六、获取任务

// 此方法有三种可能:

// 1. 阻塞直到获取到任务返回。我们知道,默认 corePoolSize 之内的线程是不会被回收的,

//      它们会一直等待任务

// 2. 超时退出。keepAliveTime 起作用的时候,也就是如果这么多时间内都没有任务,那么应该执行关闭

// 3. 如果发生了以下条件,此方法必须返回 null:

//    - 池中有大于 maximumPoolSize 个 workers 存在(通过调用 setMaximumPoolSize 进行设置)

//    - 线程池处于 SHUTDOWN,而且 workQueue 是空的,前面说了,这种不再接受新的任务

//    - 线程池处于 STOP,不仅不接受新的线程,连 workQueue 中的线程也不再执行

private RunnablegetTask() {

boolean timedOut =false; // Did the last poll() time out?

    retry:

for (;;) {

int c = ctl.get();

        int rs = runStateOf(c);

        // 两种可能

// 1. rs == SHUTDOWN && workQueue.isEmpty()

// 2. rs >= STOP

        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {

// CAS 操作,减少工作线程数

            decrementWorkerCount();

return null;

        }

boolean timed;      // Are workers subject to culling?

        for (;;) {

int wc = workerCountOf(c);

            // 允许核心线程数内的线程回收,或当前线程数超过了核心线程数,那么有可能发生超时关闭

            timed = allowCoreThreadTimeOut || wc > corePoolSize;

            // 这里 break,是为了不往下执行后一个 if (compareAndDecrementWorkerCount(c))

// 两个 if 一起看:如果当前线程数 wc > maximumPoolSize,或者超时,都返回 null

// 那这里的问题来了,wc > maximumPoolSize 的情况,为什么要返回 null?

//    换句话说,返回 null 意味着关闭线程。

// 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了

            if (wc <= maximumPoolSize && ! (timedOut && timed))

break;

            if (compareAndDecrementWorkerCount(c))

return null;

            c = ctl.get();  // Re-read ctl

// compareAndDecrementWorkerCount(c) 失败,线程池中的线程数发生了改变

            if (runStateOf(c) != rs)

continue retry;

            // else CAS failed due to workerCount change; retry inner loop

        }

// wc <= maximumPoolSize 同时没有超时

        try {

// 到 workQueue 中获取任务

            Runnable r = timed ?

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

workQueue.take();

            if (r !=null)

return r;

            timedOut =true;

        }catch (InterruptedException retry) {

// 如果此 worker 发生了中断,采取的方案是重试

// 解释下为什么会发生中断,这个读者要去看 setMaximumPoolSize 方法,

// 如果开发者将 maximumPoolSize 调小了,导致其小于当前的 workers 数量,

// 那么意味着超出的部分线程要被关闭。重新进入 for 循环,自然会有部分线程会返回 null

            timedOut =false;

        }

}

}

七、案例分析

ThreadPoolExecutor pool =new ThreadPoolExecutor(1,2,60, TimeUnit.SECONDS,new ArrayBlockingQueue<>(3));

MyTask task1 =new MyTask(1,"任务1");

MyTask task2 =new MyTask(2,"任务2");

MyTask task3 =new MyTask(3,"任务3");

MyTask task4 =new MyTask(4,"任务4");

MyTask task5 =new MyTask(5,"任务5");

pool.execute(task1);

pool.execute(task2);

pool.execute(task3);

pool.execute(task4);

pool.execute(task5);

八、总结

1. 线程池中的线程创建时机

如果当前线程数少于 corePoolSize,那么提交任务的时候创建一个新的线程,并由这个线程执行这个任务;

如果当前线程数已经达到 corePoolSize,那么将提交的任务添加到队列中,等待线程池中的线程去队列中取任务;

如果队列已满,那么创建新的线程来执行任务,需要保证池中的线程数不会超过 maximumPoolSize,如果此时线程数超过了 maximumPoolSize,那么执行拒绝策略。

2. 关键属性

corePoolSize 到 maximumPoolSize 之间的线程会被回收,当然 corePoolSize 的线程也可以通过设置而得到回收(allowCoreThreadTimeOut(true))。

workQueue 用于存放任务,添加任务的时候,如果当前线程数超过了 corePoolSize,那么往该队列中插入任务,线程池中的线程会负责到队列中拉取任务。

keepAliveTime 用于设置空闲时间,如果线程数超出了 corePoolSize,并且有些线程的空闲时间超过了这个值,会执行关闭这些线程的操作

rejectedExecutionHandler 用于处理当线程池不能执行此任务时的情况,默认有抛出 RejectedExecutionException 异常忽略任务使用提交任务的线程来执行此任务将队列中等待最久的任务删除,然后提交此任务这四种策略,默认为抛出异常。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 212,029评论 6 492
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 90,395评论 3 385
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 157,570评论 0 348
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 56,535评论 1 284
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 65,650评论 6 386
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 49,850评论 1 290
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 39,006评论 3 408
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 37,747评论 0 268
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 44,207评论 1 303
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,536评论 2 327
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,683评论 1 341
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 34,342评论 4 330
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 39,964评论 3 315
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,772评论 0 21
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,004评论 1 266
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 46,401评论 2 360
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 43,566评论 2 349

推荐阅读更多精彩内容