深度剖析线程池

最新推荐文章于 2025-05-12 11:03:28 发布

幻想波普星

最新推荐文章于 2025-05-12 11:03:28 发布

阅读量213

点赞数

CC 4.0 BY-SA版权

分类专栏： java多线程文章标签：线程池多线程并发 threadpool java

本文链接：https://blog.csdn.net/qq_26364669/article/details/102772386

java多线程专栏收录该内容

12 篇文章

订阅专栏

之前在网上看一些面试题，每每看到线程池相关的都有种心虚的感觉，总感觉似懂非懂，禁不起敲打，也罢，好好写篇文章学习下线程池就。

类的结构

在这里插入图片描述

ExecutorService是我们常用的接口，继承了Ececutor，在Executor的基础上添加了很多功能。

ThreadPoolExecutor就是我们线程池的核心类了，可以用它的构造方法实现多种不同的线程池。

还有一种线程池ScheduledThreadPoolExecutor，适用于定时任务实现，碍于篇幅本文不再介绍

另外，还有个Executors类似于Collections，是个工具类，提供了直接生成一些常用线程池的方法，其实就是内部报了一个ThreadPoolExecuto，如下所示。

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

Executor

void execute(Runnable command);

Executor中只有这一个方法，可以看到是没有返回结果的。

ExecutorService

public interface ExecutorService extends Executor {
    
    // 关闭线程池，已提交的任务可以继续执行，不接受新任务
    void shutdown();
    
    // 会停掉正在进行的任务，上边方法则不会
    List<Runnable> shutdownNow();

    // 线程池是否关闭
    boolean isShutdown();

    // 所有任务都结束且线程池和任务队列都为空返回true
    boolean isTerminated();
    
    // 等待所有任务完成
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    // 提交一个Callable 任务
    <T> Future<T> submit(Callable<T> task);

    // 提交一个Runnable接口，第二个参数放入future，作为返回值
    <T> Future<T> submit(Runnable task, T result);
    
    // 提交一个Runnable任务
    Future<?> submit(Runnable task);
}

需要获取结果，用submit / 不需要获取结果，用execute

AbstractExecutorService


// 将runnable 封装为 FutureTask
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}
    
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

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

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

   
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

AbstractExecutorService中提供了将普通线程封装为FutureTask，FutureTask是RunnableFuture(继承自Runnable，Future)的子类，可以看到执行方法也都是执行RunnableFuture。

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

这就是最常用的方法，可以看到上边工具类Executors中的得到一个指定线程池也是按这个构造方法来的。就从这个方法入手开始吧。
首先看一下各个参数的含义。

corePoolSize 核心线程数
maximumPoolSize 最大线程数，线程池允许创建的最大线程数。
workQueue 任务队列，BlockingQueue 接口的某个实现
keepAliveTime 关闭线程池中长时间不用的线程，这个时间就是keepAliveTime，这个值并不会对所有线程起作用，如果线程池中的线程数少于等于corePoolSize，那么这些线程不会因为空闲太长时间而被关闭
threadFactory 用于生成线程
handler 当线程池已经满了，但是又有新的任务提交的时候，该采取什么策略

还有其他一些属性

// 高3位表示线程池状态，低29位表示线程数，默认RUNNING,线程数0
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

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

// 线程最大个数
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// 1110 0000 0000 0000 0000 0000 0000 0000
private static final int RUNNING    = -1 << COUNT_BITS;
// 0000 0000 0000 0000 0000 0000 0000 0000
private static final int SHUTDOWN   =  0 << COUNT_BITS;
// 0001 0000 0000 0000 0000 0000 0000 0000
private static final int STOP       =  1 << COUNT_BITS;
// 0010 0000 0000 0000 0000 0000 0000 0000
private static final int TIDYING    =  2 << COUNT_BITS;
// 0011 0000 0000 0000 0000 0000 0000 0000
private static final int TERMINATED =  3 << COUNT_BITS;

// 获取高3位(运行状态)
private static int runStateOf(int c)     { return c & ~CAPACITY; }

// 获取低29位 线程数
private static int workerCountOf(int c)  { return c & CAPACITY; }

// 计算ctl新值（线程状态与个数）
private static int ctlOf(int rs, int wc) { return rs | wc; }

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

// 全局锁
private final ReentrantLock mainLock = new ReentrantLock();

private final HashSet<Worker> workers = new HashSet<Worker>();

线程状态

说一下上边提到的五种状态

RUNNING 正常状态
SHUTDOWN 不接受新的任务提交，但是会继续处理等待队列中的任务
STOP 不接受新任务提交，不处理等待队列中任务，中断正在执行任务
TIDYING 所有任务都销毁了，workcount(线程数)为0，线程池状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()
TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个

状态转换

RUNNING -> SHUTDOWN：当调用了 shutdown()
(RUNNING or SHUTDOWN) -> STOP：当调用 shutdownNow()
SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING
STOP -> TIDING 任务队列（workQueue）清空后
TIDYING -> TERMINATED 钩子方法 terminated()执行后

接着引入我们线程池中的一个内部类Worker，工人，即线程池中做任务的线程，不要弄混，在线程池中，任务是Runnable，在类中也叫task/command，线程指的就是Worker。

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{

    // 这个是真正的做任务的线程
    final Thread thread;

    // 前面说了，这里的 Runnable 是任务。 firstTask即创建线程的时候，如果同时指定了
    // 这个线程起来以后需要执行的第一个任务，那么第一个任务就是存放在这里的(线程可不止执行这一个任务)
    // 当然了，也可以为 null，这样线程起来了，自己到任务队列（BlockingQueue）中取任务（getTask 方法）就行了
    Runnable firstTask;

    // 用于存放此线程完成的任务数， 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 操作，来获取这个线程的执行权，用了独占锁
}

可以看到worker内部封装了一个线程。

接着来看下execute(Runnable command),我们上边说过AbstractExecutorService中的submit最后也是要调用execute的，来看下吧

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
            
        int c = ctl.get();

        if (workerCountOf(c) < corePoolSize) {
            // 线程池中的线程数<核心线程数，创建线程并把command作为first task，成功的话直接返回
            if (addWorker(command, true))
                return;
            // 到了这，说明添加线程没成功，再次获取c    
            c = ctl.get();
        }
        // 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了
        
        if (isRunning(c) && workQueue.offer(command)) {
            // 此时command加入任务队列
            int recheck = ctl.get();
            // 此时线程池不是RUNNING,移除入队任务，拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 线程池RUNNING但是线程数为0，也就是工人数为0，没人干活不行啊，所以开新线程    
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //  workQueue队列满进入该分支创建新的Worker（以为maxPoolSize为边界
        //执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

看的有点懵是吧，没关系，往后看，我们会回过头来看的

来看下这个addWorker

/**
 * @param firstTask 前边说过，创建线程后指定去执行的第一个任务，可以为null
 * @param core true代表使用corePoolSize作为创建线程界限；false则是maximumPoolSize
 */
private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            //如果线程池已关闭且满足以下条件之一返回false不创建新的worker
            // 1 状态大于SHUTDOWN
            // 2 状态是SHUTDOWN且firstTask！=null，这个是null，线程其实还是可创建的，这个是null的话，新创建一个创建是从队列上拿任务，并不违反SHUTDOWN语义，注意这个firstTask是我们指定的，参数传过来的（是个新任务）。
            // 3 状态是SHUTDOWN且workQueue.isEmpty()
            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;
                c = ctl.get();  
                // 状态改了需要重回外层循环，否则内层重新CAS
                if (runStateOf(c) != rs)
                    continue retry;
                retry inner loop
            }
        }
        
        
        // 到这里说明CAS成功增加了线程个数
        
        // worker是否启动
        boolean workerStarted = false;
        // worker是否添加到workers这个hashset
        boolean workerAdded = false;
        Worker w = null;
        try {
            // 新建线程，firstTask传过来给新线程
            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且firstTask==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 {
            // 线程没有启动成功，做一些处理清理
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
    
// 线程没有启动成功做的清理工作，包括移除刚才新建worker，线程数再减回去
private void addWorkerFailed(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }

好长好长的一个方法，总算是冽干净了。其实总结起来很简单，先CAS增加线程数，然后把持独占锁，创建线程并启动，启动成功就去执行任务，失败就去做清理工作。

我们知道启动后，就会去执行run(),接着执行runWorker()

final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // 将state设置为0，允许中断
        boolean completedAbruptly = true;
        try {
            // 不停获取任务
            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) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    // 累加完成的任务数
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            // 执行清理工作
            processWorkerExit(w, completedAbruptly);
        }
    }

此时回头去看execute

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
            
        int c = ctl.get();

        if (workerCountOf(c) < corePoolSize) {
            // 线程池中的线程数<核心线程数，创建线程并把command作为first task，成功的话直接返回
            if (addWorker(command, true))
                return;
            // 到了这，说明添加线程没成功，再次获取c    
            c = ctl.get();
        }
        // 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了
        
        if (isRunning(c) && workQueue.offer(command)) {
            // 此时command已经加入任务队列，这里需要考虑是否需要增加worker，线程数小于corePoolSize是无条件添加，否则将任务添加到队列来到这一步
            int recheck = ctl.get();
            // 此时线程池不是RUNNING,移除入队任务，拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 线程池RUNNING但是线程数为0，也就是工人数为0，没人干活不行啊，所以开新线程    
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //  workQueue队列满进入该分支，以maxPoolSize为界创建Worker，如果失败
        //执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

总结

好累啊这篇文章，总算到尾声了。来看一下一些关键点吧。

Worker 线程池中的工人，内部封装了一个线程，当线程数小于corePoolSize，新来一个任务就会开一个线程
workQueue 工作队列，当线程数大于corePoolSize时，新任务就会被加入该队列中，当该队列拉满了，就会以maxPoolSize为边界创建worker
任务执行过程中出现异常，比如启动失败，那么线程就会被回收
拒绝策略，这个本文小于篇幅就不讲了，实际上很简单，顾名思义，你怎么拒绝这个任务，抛弃OR不管等等随你定。观察execute方法，两次执行拒绝策略，第一次是入队成功的同时线程池的关闭导致，第二次是线程数达到了maxPoolSize。

公众号： 程序员二狗

每日原创文章，一起交流学习