Java线程池底层原理
文章目录
-
- 1. 线程和现场池的对比
- 2. ThreadPoolExecutor分析
- 3. ThreadPoolExecutor源码详解
1. 线程和现场池的对比
下面代码创建了100000个线程
public class Main {
public static void main(String[] args) throws InterruptedException {
Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
for(int i=0; i<100000; i++){
Thread thread = new Thread() {
@Override
public void run() {
list.add(random.nextInt());
}
};
thread.start();
thread.join();
}
System.out.println("时间:" + (System.currentTimeMillis()-start));
System.out.println("大小:" + list.size());
}
}
使用了14s左右的时间执行
而下面代码则使用线程池
public class Main {
public static void main(String[] args) throws InterruptedException {
Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
//创建只有一个线程的线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();
for(int i=0;i<100000;i++){
executorService.execute(new Runnable() {
@Override
public void run() {
list.add(random.nextInt());
} });
}
executorService.shutdown();
executorService.awaitTermination(1, TimeUnit.DAYS);
System.out.println("时间:"+(System.currentTimeMillis()-start));
System.out.println("大小:"+list.size());
}
}
发现时间只需要97ms，性能得到了大大的提升，那为什么提升会如此大？原因是代码1使用了100000个线程，而代码2只使用到了1个线程，要知道线程的创建以及上下文切换都是十分消耗CPU资源的，而代码1大量的时间都花到了这部分上面。所以在这种场景下使用线程池会更快一些，但使用线程池一定会更快吗？ 看下面的代码：
public class Main {
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService1 = Executors.newCachedThreadPool();
ExecutorService executorService2 = Executors.newFixedThreadPool(10);
ExecutorService executorService3 = Executors.newSingleThreadExecutor();
for (int i = 0; i < 100; i++) {
executorService3.execute(new MyTask(i));
}
}
}
class MyTask implements Runnable {
int i = 0;
public MyTask(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"第"+i+"个任务");
try{
Thread.sleep(300L);
}catch (Exception e){
e.printStackTrace();
}
}
}
上面代码我们分别用三个线程池来执行100个任务，执行结果可以发现，三个线程池由上到下速度越来越慢，前面我们代码知道了Executors.newSingleThreadExecutor这个线程池执行100000个任务的速度非常快，那为什么这里执行100个任务却这么慢呢。这时候我们就需要从我们执行的任务类型开始分析，首先从源码开始分析：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
可以发现三个线程池底层都是基于ThreadPoolExecutor 这个类创建的，我们来重点分析一下这个类。
2. ThreadPoolExecutor分析
ThreadPoolExecutor的构造函数源码如下
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
corePoolSize：核心线程数，核心线程数是线程池中一直存在的线程数量，即使它们处于空闲状态
maximumPoolSize：最大线程数，最大线程数是线程池允许的最大线程数量，包括空闲和活动线程。
BlockingQueue：阻塞队列，存储我们要执行的任务
ThreadFactory：线程工厂，用来创建线程
keepAliveTime：线程生命周期
newCachedThreadPool
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
corePoolSize：核心线程数为0
maximumPoolSize：最大线程数为Integer.MAX_VALUE
线程生命周期：60s
可以发现newCachedThreadPool这个现场池没有核心线程，它返回一个可以根据需要创建新线程的线程池，但在先前构建的线程可用时将重用它们。它的特点主要如下：
- 动态线程数： newCachedThreadPool 创建一个具有可变大小的线程池，根据需要动态地创建新的线程。如果有可用的空闲线程，它将重用这些线程，否则将创建新线程。
- 无限制线程数： 线程池的最大线程数理论上是无限的，因为它可以根据需要动态创建新线程。这可能会导致线程数在极端情况下无限增长，因此在某些情况下需要谨慎使用，以防止资源耗尽。
- 自动线程回收： 如果某个线程在60秒内没有被使用（空闲状态），则该线程将被终止并从线程池中移除。这有助于自动释放系统资源。
- 适用于短生命周期的异步任务： 适用于执行大量的、相对较短的任务，因为线程池会根据需要创建新线程，并在空闲一段时间后终止不再需要的线程。
- 不适用于长时间运行的任务： 由于线程池的最大线程数理论上是无限的，不适用于长时间运行的任务，因为这可能导致线程数过多，从而影响性能。
newFixedThreadPool
newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
corePoolSize：核心线程数为1
maximumPoolSize：最大线程数为10
线程生命周期：永久
LinkedBlockingQueue：阻塞队列的大小无限大
该线程池将一直保持指定数量的线程，即核心线程数，在任何时候都是活动的。如果有新的任务提交，而线程池中的线程数尚未达到核心线程数，将会创建新线程来处理任务。以下是 newFixedThreadPool 的主要特点：
- 固定线程数： newFixedThreadPool 创建一个具有固定数量线程的线程池，这个数量在创建线程池时被指定。
- 无限制的工作队列： 线程池使用一个无界的工作队列（LinkedBlockingQueue）来保存等待执行的任务。这意味着如果任务提交速度超过了线程池处理任务的速度，任务将被放入队列中等待执行，而不会导致线程数继续增加。
- 适用于长时间运行的任务： 适用于执行长时间运行的任务，因为线程池中的线程数是固定的，不会根据任务的数量而动态变化。
- 控制资源占用： 由于线程数是固定的，可以更好地控制系统资源的占用，不会因为任务数量过多而导致过度的线程创建。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
corePoolSize：核心线程数为1
maximumPoolSize：最大线程数为1
线程生命周期：永久
LinkedBlockingQueue：阻塞队列的大小无限大
是一个只包含单个线程的线程池。该线程池确保所有任务按照它们被提交的顺序执行，并且在任何时候都只有一个线程处于活动状态。以下是 newSingleThreadExecutor 的主要特点：
- 单线程执行： newSingleThreadExecutor 创建一个只有一个线程的线程池。这意味着所有任务都将按照它们被提交的顺序在同一个线程中执行。
- 无限制的工作队列： 类似于 newFixedThreadPool，newSingleThreadExecutor 也使用一个无界的工作队列（LinkedBlockingQueue）来保存等待执行的任务。
- 适用于需要顺序执行的任务： 适用于需要按照提交顺序执行的任务，确保任务之间不会并发执行。
- 线程异常处理： 由于只有一个线程，因此可以更容易地捕获和处理线程抛出的异常。
下面就来解释一下为什么上面不同的线程池执行速度会不同，对于newCachedThreadPool，它会根据需要创建很多线程，也会出现线程复用的情况所以它执行速度很快，然后newFixedThreadPool它只创建了10个线程去执行100个任务，速度会比newCachedThreadPool慢，最后是newSingleThreadExecutor它只有一个线程执行100个任务所以它是最慢的。这就是从线程池角度出发，为什么会出现上面不同线程池执行速度不同的情况。然后从任务的角度出发，对于newSingleThreadExecutor它前面执行100000个任务，由于任务很小（代码可以看出）能在瞬间完成，这个唯一的线程能不断复用，所以速度会非常快。而对于Mytask任务，该任务里面执行了sleep()函数，算一个比较大的任务，所以单一线程会执行非常慢。这就是出现前面情况的原因。
注意：阿里规范是不推荐使用JDK提供的线程池的
- 线程资源无限制： Executors.newCachedThreadPool 和 Executors.newFixedThreadPool 等工厂方法创建的线程池，由于没有明确地设置最大线程数或工作队列容量，可能会导致线程资源无限制地增长，从而影响系统的稳定性。
- 无法控制线程池的最大大小： 这些工厂方法创建的线程池，虽然能够满足任务提交需求，但是它们没有提供直接的方式来设置合理的最大线程数，特别是在并发任务量剧增的情况下。
- 无界队列可能导致内存溢出： Executors.newCachedThreadPool 和 Executors.newFixedThreadPool 默认使用无界的任务队列，如果任务提交速度远远快于线程池处理速度，会导致队列无限增长，最终可能导致内存溢出。
相反，阿里规范推荐使用ThreadPoolExecutor手动创建线程池，以便有更多的控制权。通过手动配置 ThreadPoolExecutor 的参数，可以限制线程的数量、设置合理的队列大小，并明确定义饱和策略。这样可以更好地适应不同的业务场景和负载情况，提高系统的稳定性和可维护性。
3. ThreadPoolExecutor源码详解
如下面我们自定义了一个线程池来执行前面的Mytask任务，现场池有10个核心线程，20个最大现场数，阻塞队列的大小为10个，仔细观察执行结果：
public class Main {
public static void main(String[] args) throws InterruptedException {
ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(
10,
20,
0L,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(10));//自定义线程
for (int i = 0; i < 100; i++) {
threadPoolExecutor.execute(new MyTask(i));
}
}
}
- 我们发现执行任务是无序的
- 出现了拒绝任务的错误
为了分析出现上面两个情况的原因，我们要深入ThreadPoolExecutor的源码进行分析。
- ThreadPoolExecutor类结构图
- Executor类
Executor 接口是 Java 并发框架的一部分，它定义了一种执行任务的简单机制。
public interface Executor {
/**
* 在将来的某个时间执行给定的命令。
* 该命令可以在新线程、池化线程或调用线程中执行，这由 Executor 的实现决定。
*
* @param command 要执行的命令
* @throws RejectedExecutionException 如果不能接受该任务，则抛出此异常。
* @throws NullPointerException 如果命令为 null，则抛出此异常。
*/
void execute(Runnable command);
}
- ExecutorService
ExecutorService 是 Executor 接口的子接口，它扩展了 Executor 的功能，提供了更丰富的任务执行和管理功能。ExecutorService 主要用于执行和管理异步任务，可以提交任务、取消任务、获取任务执行的结果等。
public interface ExecutorService extends Executor {
//平缓地关闭执行器，不再接受新任务，但会等待已经提交的任务执行完成。
void shutdown();
//立即关闭执行器，尝试停止所有正在执行的任务，并返回等待执行的任务列表。
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
//提交一个可调用的任务，并返回一个表示该任务未来结果的 Future。
<T> Future<T> submit(Callable<T> task);
//提交一个可运行的任务，并返回一个表示该任务未来结果的 Future。
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
//执行给定的任务列表，返回一个包含 Future 的列表，表示任务的未来结果。在所有任务完成之前，此方法将阻塞。
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
- AbstractExecutorService
AbstractExecutorService 是 ExecutorService 接口的抽象实现，它提供了一些基本的执行器服务功能，使得实现 ExecutorService 接口的类能够更容易地实现这个接口。
public abstract class AbstractExecutorService implements ExecutorService {
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;
}
}
ThreadPoolExecutor
我们在定义完ThreadPoolExecutor后会调用excute方法去执行任务
execute
public void execute(Runnable command) {
//任务为空抛出空指针异常
if (command == null)
throw new NullPointerException();
//获取当前线程池的控制状态（ctl 是 AtomicInteger 类型的变量，用于表示线程池的状态和工作线程数）。
int c = ctl.get();
//检查当前工作线程数量是否小于核心线程数 (corePoolSize)。如果是，尝试通过 addWorker 方法增加一个核心线程来执行任务。如果成功添加了线程，则直接返回，任务将由新线程执行。如果无法添加线程，则重新获取控制状态并继续执行后续逻辑。
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果无法添加核心线程，检查线程池是否处于运行状态（isRunning(c)）。如果是，并且成功将任务放入工作队列 (workQueue.offer(command))，则继续执行。
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//如果此时线程池不再运行，并且任务无法从队列中移除，说明任务将被拒绝（reject）。
if (! isRunning(recheck) && remove(command))
reject(command);
//如果此时线程池中没有工作线程，则尝试添加一个非核心线程（addWorker(null, false)）。
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//如果无法将任务添加到工作队列中，则尝试通过 addWorker 方法添加一个非核心线程来执行任务。如果无法添加非核心线程，则说明线程池已经饱和，任务将被拒绝。
else if (!addWorker(command, false))
reject(command);
}
- 1-10的任务可以交给核心线程去执行
- 11-20的任务会放在阻塞队列中
- 21-30的任务由于阻塞队列满了，所以会创建10个非核心线程执行
- 31的任务无法处理了直接执行拒绝策略
以上就是为什么会出现拒绝错误的问题
addWorker
上面execute源码我们可以看出多次调用了addWorker，这个方法用于尝试添加一个新的工作线程到线程池，下面我们来详细分析一下这个方法。
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
//首先，使用一个无限循环标签retry开始迭代。在每次迭代中，首先获取当前的控制状态c和运行状态rs。
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 然后，检查线程池的运行状态是否已经达到 SHUTDOWN 或更高，并且工作队列为空。如果是，说明线程池已经关闭或正在关闭，并且工作队列已经为空，此时不应该再添加新的线程，返回false。
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
//在内层循环中，检查工作线程数是否达到线程池容量的上限（CAPACITY）或者达到了当前设置的核心线程数或最大线程数上限。如果工作线程数已经超过上限，则直接返回 false，不再添加新的线程。
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//如果可以增加工作线程数，通过 compareAndIncrementWorkerCount(c) 尝试原子地增加工作线程数。如果成功增加，则跳出外层循环，返回 true 表示成功添加了工作线程。如果增加失败，重新获取控制状态 c 并检查运行状态是否发生了变化。如果运行状态发生变化，重新进入外层循环进行重试。
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
}
}
//workerStarted 和 workerAdded 是用于记录是否成功启动工作线程的标志。
boolean workerStarted = false;
boolean workerAdded = false;
//创建一个Worker 对象，Worker 是 ThreadPoolExecutor中的内部类，表示线程池中的工作线程。
Worker w = null;
try {
//首先通过new Worker(firstTask) 创建一个新的工作线程对象，final Thread t = w.thread; 获取该工作线程的Thread对象。
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
//获取mainLock，这是线程池的主锁，确保在更新线程池状态和工作线程集合时是同步的。
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//在获取锁的情况下，再次检查线程池的运行状态 rs。只有在线程池处于运行状态（SHUTDOWN 状态及以上），或者线程池处于关闭状态且提交的任务为 null 时，才允许添加工作线程。
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();
//在获取锁的情况下，再次检查线程池的运行状态 rs。只有在线程池处于运行状态（SHUTDOWN 状态及以上），或者线程池处于关闭状态且提交的任务为 null 时，才允许添加工作线程。
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//如果成功添加了工作线程（非核心线程），调用 t.start() 启动工作线程，并将 workerStarted 设置为 true
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
简而言之上面代码就是做了一件事，检查现场池的状态，然后根据状态是否考虑将工作现场加入到现场池中开始执行任务。执行任务调用的是t.start()方法，默认执行现场的Worker类的run方法，如下
public void run() {
runWorker(this);
}
run方法中调用了一个runWorker方法
final void runWorker(Worker w) {
//Thread wt = Thread.currentThread(); 获取当前工作线程的 Thread 对象。
Thread wt = Thread.currentThread();
//Runnable task = w.firstTask; 获取工作线程的初始任务。
Runnable task = w.firstTask;
//w.firstTask = null; 清空工作线程的初始任务。（用于线程复用）
w.firstTask = null;
//w.unlock(); 解锁工作线程，允许被中断。
w.unlock(); // allow interrupts
//用于标记工作线程是否突然终止，默认为 true。
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 {
// 执行任务的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 {
processWorkerExit(w, completedAbruptly);
}
}
这段代码描述了工作线程的主要执行逻辑，其中包括任务的获取、执行、异常处理、线程状态的检查以及线程的清理工作。
