线程池基本使用及原理分析_线程池使用-CSDN博客

本文链接：https://blog.csdn.net/tufeng1992/article/details/107940746

线程池基本使用及原理分析

从源码入手，分析线程池的基本使用场景以及核心代码原理分析。分析版本：jdk1.8

文章目录

线程池基本使用及原理分析

线程池介绍

In computer programming, a thread pool is a software design pattern for achieving concurrency of execution in a computer program. Often also called a replicated workers or worker-crew model,[1] a thread pool maintains multiple threads waiting for tasks to be allocated for concurrent execution by the supervising program. By maintaining a pool of threads, the model increases performance and avoids latency in execution due to frequent creation and destruction of threads for short-lived tasks.[2] The number of available threads is tuned to the computing resources available to the program, such as parallel processors, cores, memory, and network sockets.[3]

– 摘要自维基百科

线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

– 摘要自百度百科

介绍一般都能理解，池这个概念，在平常的开发中也非常常见，例如数据库的连接池这些。主要还是为了方便管理和控制开销。

基本使用

@Test
public void contextLoads() throws IOException {
    //创建一个固定大小的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(10);
	//执行线程
    executorService.execute(() -> {
        System.out.println("running thread " + Thread.currentThread());
    });
    //关闭线程池
    executorService.shutdown();
    System.in.read();
}

上面的代码，就是一个简单的线程池使用方法。Executors是JUC提供的一个简单使用线程池的工具类，为不是很了解线程池的开发者提供了一层封装。

上面的代码是创建了一个FixedThreadPool。在Executors中还提供了一些其他的线程池的创建方法。

FixedThreadPool

创建一个固定大小的线程池

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

CachedThreadPool

这个线程池核心线程数为0，在执行线程时会优先判断是否有可用线程，如果有则使用，如果没有则创建。60秒后，线程被释放（下面的案例中）。

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

SingleThreadExecutor

创建一个只包含单个线程的线程池。

public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}

ScheduledThreadPoolExecutor

支持延迟执行的线程池。

public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
}

除了以上四种外，Executors中还提供了一些其他的线程池有需要可以简单了解一下。

原理分析

线程池创建

从上面的几种线程看到，最终核心部分还是在于线程池的创建。下面是线程池创建的构造方法：

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set 
 * @param maximumPoolSize the maximum number of threads to allow in the 
 *        pool
 * @param keepAliveTime when the number of threads is greater than 
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * @param unit the time unit for the {@code keepAliveTime} argument 
 * @param workQueue the queue to use for holding tasks before they are 
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 * @param threadFactory the factory to use when the executor 
 *        creates a new thread
 * @param handler the handler to use when execution is blocked 
 *        because the thread bounds and queue capacities are reached
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code threadFactory} or {@code handler} is null
 */
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;
}

corePoolSize：核心线程数

maximumPoolSize：最大线程数

keepAliveTime：非核心线程的存活时间

unit：时间的单位

workQueue：这个是任务的队列

threadFactory：线程工厂类

handler：执行拒绝策略时的回调，类似熔断的补偿

上面的部分不同类型的线程池实际就是通过调整这些参数实现的。

线程执行

流程图

线程池执行流程图

execute

下面是线程池执行调度线程的方法：

/**
 * Executes the given task sometime in the future.  The task
 * may execute in a new thread or in an existing pooled thread.
 *
 * If the task cannot be submitted for execution, either because this
 * executor has been shutdown or because its capacity has been reached,
 * the task is handled by the current {@code RejectedExecutionHandler}.
 *
 * @param command the task to execute
 * @throws RejectedExecutionException at discretion of
 *         {@code RejectedExecutionHandler}, if the task
 *         cannot be accepted for execution
 * @throws NullPointerException if {@code command} is null
 */
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    int c = ctl.get();//这里的ctl是用来保存线程池的运行状态和线程数量，高低位运算的机制，高3位用来存状态，低29位用来保存线程数量
    if (workerCountOf(c) < corePoolSize) {//判断当前运行的线程数是否小于核心线程数
        if (addWorker(command, true))//添加工作线程，true false表示是否核心线程
            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)//线程都被释放，新建一个线程
            addWorker(null, false);
    }
    else if (!addWorker(command, false))//如果不能添加到队列，尝试添加一个新的线程，如果失败，执行拒绝策略
        reject(command);
}

上面就是执行的大致流程，其实都是一些判断。具体的执行步骤实际在源码中作者已经有了标注：

/*
 * Proceed in 3 steps:
 *
 * 1. If fewer than corePoolSize threads are running, try to
 * start a new thread with the given command as its first
 * task.  The call to addWorker atomically checks runState and
 * workerCount, and so prevents false alarms that would add
 * threads when it shouldn't, by returning false.
 *
 * 2. If a task can be successfully queued, then we still need
 * to double-check whether we should have added a thread
 * (because existing ones died since last checking) or that
 * the pool shut down since entry into this method. So we
 * recheck state and if necessary roll back the enqueuing if
 * stopped, or start a new thread if there are none.
 *
 * 3. If we cannot queue task, then we try to add a new
 * thread.  If it fails, we know we are shut down or saturated
 * and so reject the task.
 */

而执行的核心代码，在于addWorker，接下来分析一下addWorker的核心代码。

addWorker

private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {//其实这段代码就是检查一下状态和队列情况，然后cas工作线程数
        int c = ctl.get();
        int rs = runStateOf(c);
		//检查线程池状态
        //如果线程池已经shutdown，不会接受新的任务，但是未执行完的任务还是会继续执行
        // Check if queue empty only if necessary.
        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))//cas工作线程数，成功跳出循环
                break retry;
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)//如果状态发生变化，continue
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    boolean workerStarted = false;//启动标识
    boolean workerAdded = false;//添加成功标识
    Worker w = null;
    try {
        w = new Worker(firstTask);//这里的worker实现了Runnable
        final Thread t = w.thread;//执行worker的线程
        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());
				//检查线程池状态、检查firstTask状态、检查worker线程状态
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);//将worker添加到集合
                    int s = workers.size();
                    if (s > largestPoolSize)//如果集合长度大于最大线程数，更新记录最大线程数
                        largestPoolSize = s;
                    workerAdded = true;//标识添加成功标识
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {//添加成功后，启动worker中的线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)//如果失败了，会去执行回滚
            addWorkerFailed(w);//执行回滚
    }
    return workerStarted;
}

addWorker的方法就是做一些判断校验，以及将firstTask添加到工作线程worker中。实际将逻辑委派给worker来执行，所以还需要了解一下worker的执行逻辑。worker的run方法中是调用runWorker()，因此看一下runWorker的方法逻辑。

runWorker

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;//拿到初始化的firstTask
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        //这个线程就是从task中取任务，如果任务不为空就一直循环执行任务
        while (task != null || (task = getTask()) != null) {//这里的getTask是从阻塞队列中取任务
            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方法，而不是通过线程启动的
                    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 {
        //销毁worker
        processWorkerExit(w, completedAbruptly);
    }
}

分析完runWorker方法后，可以得出，task任务的执行实际就是通过直接调用task的run方法来完成的，而在执行完一个任务后，会循环从队列中取任务，在任务都执行完成后，去销毁worker。这块逻辑的关注点主要在getTask()方法以及processWorkerExit()方法，也就是从队列中获取任务以及任务执行完成后的销毁。接下来逐步分析一下getTask和processWorkerExit。

getTask

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
		//判断线程池如果shutdown了并且为stop或者队列中没有任务了，则减去workerCount并返回null（返回null后线程会退出）。
        //可以看到，如果队列中还有任务，这里还是会执行完的（除非线程池STOP了）
        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
		//拿到工作线程数
        int wc = workerCountOf(c);
		//这里的timed用来做超时判断
        //allowCoreThreadTimeOut默认为false，表示核心线程默认一直保持活动
        //如果工作线程数已经大于核心线程数了，也就是非核心线程
        // 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;
        }
    }
}

分析完getTask方法可以发现，线程池如果shutdown了，任务还是会被执行完，但是如果是stop了，则不会继续执行了。核心线程通过take阻塞一直保持（除非设置了核心线程超时），非核心线程通过poll取任务，超时后会进入销毁逻辑。最后，在来看下销毁。

processWorkerExit

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);//集合中删除worker
    } finally {
        mainLock.unlock();
    }
	//尝试终止
    tryTerminate();

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {//判断是否已经终止
        if (!completedAbruptly) {//为false表示任务已经执行完了的场景
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;//这个min用来判断核心线程的数量
            if (min == 0 && ! workQueue.isEmpty())//如果核心线程keep数量为0并且任务队列不为空则会至少保持一个worker的存活
                min = 1;
            if (workerCountOf(c) >= min)//如果当前的worker已经大于配置的核心线程数量了，则让线程被销毁
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

总结

通过线程池来执行任务，原理是通过委派给一个Worker对象来完成。

Worker对象本身也实现了Runnable接口，通过一个线程启动调用到Worker对象的run方法，Worker对象在来调用任务的run方法完成对象任务的逻辑执行。Worker对象同时继承了AQS，这是为了自定义实现独占锁的功能，这是为了表示当前线程正在执行任务中，不应该被中断。

核心线程会在getTask的时候通过调用阻塞队列的take方法阻塞，直到有新的任务加入队列重新开始执行。非核心线程在执行完任务后会被销毁，超时时间的表现是在从阻塞队列中取任务时，是调用take还是poll来完成。

核心线程会被回收的场景是在设置了allowCoreThreadTimeOut参数为true后，会将超时的核心线程销毁。