线程池夺命十四问-阿里云开发者社区

一：什么是线程池

线程池：顾名思义就是一个管理线程的容器，当有任务需要处理的时候，放进任务队列里面，由线程池分配空闲的线程处理任务，处理完任务的线程不会被销毁，而是在线程池中等待下一个任务

二：线程池有什么好处

1.降低资源消耗：频繁的创建与销毁线程，占用大量资源，线程池的出现避免了这种情况，减少了资源的消耗；

2.提高响应速度：因为线程池中的线程处于待命状态，有任务进来无需等待线程的创建就能立即执行（前提是有空闲线程，任务量巨大，还是需要排队的哈）；

3.更好的管理线程：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

三：如何创建一个线程池

在Java中有两类方法可以创建一个线程池，如下：

Executors

1.Executors.newFixedThreadPool：创建一个固定大小的线程池，并且可以控制并发线程的数量，多余的线程会放在任务队列中等待执行

2.Executors.newCacheThreadPool：创建一个可缓存的线程池，若线程数量超过了线程池设置的参数，会缓存一段时间后回收

3.Executors.newSingleThreadPool：创建单个线程的线程池，他可以保证线程的顺序执行

4.Executors.newScheduledThreadPool：创建可以执行延迟任务的线程池

5.Executors.newSingleThreadScheduleExecutors：创建一个单线程可以执行延迟任务的线程池，是3和4的结合体

6.Executors.newWorkStealingPool：创建一个抢占式的线程池（是根据CPU的核数来确定的）

ThreadPoolExecutors

7.ThreadPoolExecutors：通过手动创建线程池，需要配置参数

四：创建一个线程池为什么不推荐使用Executors

如果大家跟入到Executors这些方法的底层实现中去看一眼的话，立马就知道原因了，像FixedThreadPool 和 SingleThreadExecutor这两个方法内使用的是无界的 LinkedBlockingQueue存储任务，任务队列最大长度为 Integer.MAX_VALUE,这样可能会堆积大量的请求，从而导致 OOM。而CachedThreadPool使用的是同步队列 SynchronousQueue, 允许创建的线程数量也为 Integer.MAX_VALUE ，如果任务数量过多且执行速度较慢，可能会创建大量的线程，从而导致 OOM，其他的方法所提供的均是这种无界任务队列，在高并发场景下导致OOM的风险很大，故大部分的公司已经不建议采用Executors提供的方法创建线程池了。

五：如何设置线程池的大小

通常来说设置线程数是根据业务需求和实际情况来确定的，原因如下

1.如果当前业务需求的任务类型是多IO类型的（读和写操作比较多）话，线程数可以设置的多一些（2n-1），如果业务需求的任务类型是多cpu计算型的话，那么线程数可以设置为n-1

2.线程数还与cpu的核心数有关，因为我们创建的线程池中本质还是多个线程，而Java线程是与操作系统一一对应，因此也要考虑cpu的情况

六：线程池有哪些参数

在线程池中有七大参数

1.核心线程数：即当前线程池种常驻的线程数量，如果是0的话，则会销毁线程池

2.最大线程数：当有最多任务的时候，该线程池中所有的线程数量

3.临时线程存活时间：如果线程池空闲，除了核心线程以外的临时线程，在超过改时间后会消亡

4.临时线程存活时间单位：临时线程的存活时间单位，一般为毫秒

5.任务阻塞队列：当线程池中所有的线程都在执行任务时，又有新的任务来时，会放进任务阻塞i队列中。

6.线程工厂：是一个创建线程池的工厂，不设置该参数时，用的是默认的线程工厂

7.拒绝策略：当任务队列都已经满了的时候，此时就会触发拒绝策略。表示不在接收新的任务

七：线程池有哪些状态

通常线程池有以下5中状态

private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

RUNNING： 线程池一旦被创建，就处于 RUNNING 状态，任务数为 0，能够接收新任务，对已排队的任务进行处理。
SHUTDOWN： 不接收新任务，但能处理已排队的任务。调用线程池的 shutdown() 方法，线程池由 RUNNING 转变为 SHUTDOWN 状态。
STOP： 不接收新任务，不处理已排队的任务，并且会中断正在处理的任务。调用线程池的 shutdownNow() 方法，线程池由(RUNNING 或 SHUTDOWN ) 转变为 STOP 状态。
TIDYING： 1）SHUTDOWN 状态下，任务数为 0，其他所有任务已终止，线程池会变为 TIDYING 状态。

2）线程池在 SHUTDOWN 状态，任务队列为空且执行中任务为空，线程池就会由 SHUTDOWN 转变为 TIDYING 状态。

3）线程池在 STOP 状态，线程池中执行中任务为空时，就会由 STOP 转变为 TIDYING 状态

TERMINATED： 线程池彻底终止。线程池在 TIDYING 状态执行完 terminated() 方法就会由 TIDYING 转变为 TERMINATED 状态。

5种状态转换如下：

八：线程池的执行流程

1、刚new出来的线程池里默认是没有线程的，只有一个传入的阻塞队列；

2、当我们执行execute提交一个方法后，会判断当前线程池中线程数是否小于核心线程数（corePoolSize），如果小于，那么就直接通过 ThreadFactory 创建一个线程来执行这个任务，当任务执行完之后，线程不会退出，而是会去阻塞队列中获取任务；

3、如果当前运行的线程数等于或大于核心线程数，但是小于最大线程数，那么就把该任务放入到任务队列里等待执行。

4、如果向任务队列投放任务失败（任务队列已经满了），但是当前运行的线程数是小于最大线程数的，就新建一个线程来执行任务。

5、如果当前运行的线程数已经等同于最大线程数了，新建线程将会使当前运行的线程超出最大线程数，那么当前任务会被拒绝，调用RejectedExecutionHandler.rejectedExecution()方法。

源码如下：

public void execute(Runnable command) {
    // 首先检查提交的任务是否为null，是的话则抛出NullPointerException。
    if (command == null)
        throw new NullPointerException();
 
    // 获取线程池的当前状态（ctl是一个AtomicInteger，其中包含了线程池状态和工作线程数）
    //private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    int c = ctl.get();
 
    // 1. 检查当前运行的工作线程数是否少于核心线程数（corePoolSize）
    if (workerCountOf(c) < corePoolSize) {
        // 如果少于核心线程数，尝试添加一个新的工作线程来执行提交的任务
        // addWorker方法会检查线程池状态和工作线程数，并决定是否真的添加新线程
        if (addWorker(command, true))
            return;
        // 重新获取线程池的状态，因为在尝试添加线程的过程中线程池的状态可能已经发生变化
        c = ctl.get();
    }
 
    // 2. 尝试将任务添加到任务队列中
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 双重检查线程池的状态
        if (! isRunning(recheck) && remove(command))  // 如果线程池已经停止，从队列中移除任务
            reject(command);
        // 如果线程池正在运行，但是工作线程数为0，尝试添加一个新的工作线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3. 如果任务队列满了，尝试添加一个新的非核心工作线程来执行任务
    else if (!addWorker(command, false))
        // 如果无法添加新的工作线程（可能因为线程池已经停止或者达到最大线程数限制），则拒绝任务
        reject(command);
}

九：如何判断一个线程池的中的任务是否执行完毕

在Java中通常有两种方式判断线程池中线程是否已经执行完毕

1.使用getTakCount总任务数和getCompletedTaskCount已经执行完毕的线程数相比较来判断，该方法缺点是在实际开发中线程池是公用的，因此总任务数是在一直不断变化的，并且得到的也是一个近似值，因此不推荐使用

2.使用FutureTask中的get()方法是等待所有线程执行完毕后才返回结果。

十：线程池的拒绝策略有哪些

在Java中有两类拒绝策略：内置的拒绝策略，自定义拒绝策略

1.在内置的拒绝策略中有四种：

1.AbortPolicy:即默认的拒绝策略，只会抛出一个异常消息

2.CallerRunsPolicy：即哪个线程提交过来的任务，就返回给哪个线程，是不会用线程池中的线程处理

3.DiscardPolicy：即默默丢弃任务，不会做任何的提醒操作

4.DiscardOldestPolicy：即丢弃任务队列中最旧的一个任务，并尝试重新提交任务

自定义拒绝策略

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
/**
 * @author: dlwlrma
 * @data 2024年09月17日 19:47
 * @Description: TODO:模拟自定义线程池拒绝策略
 */
public class ThreadDemo {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
 
            @Override
            public void run() {
                System.out.println("线程名称："+Thread.currentThread().getName());
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
 
        //创建线程，线程的任务队列长度为1
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(1), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                //自定义线程池拒绝策略
                System.out.println("执行自定义拒绝策略");
            }
        });
        threadPool.execute(runnable);
        threadPool.execute(runnable);
        threadPool.execute(runnable);
        threadPool.execute(runnable);
}
}

实际开发中，我们不会使用内置的拒绝策略，是因为当内置的拒绝策略过于简单，不利于维护，因此常用自定义的拒绝策略，例如在自定义的拒绝策略中加入mq,当触发了拒绝策略时，发布者会收集异常信息，然后订阅者会根据异常id去处理异常等等

十一：线程池的线程是如何复用的

线程池的核心功能就是实现线程的重复利用，那么线程池是如何实现线程的复用呢？线程池通过addWorker()方法添加任务，而在这个方法的底层会将任务和线程一起封装到一个Worker对象中，Worker 继承了 AQS，也就是具有一定锁的特性。

然后Worker中有一个run方法，执行时会去调用runWorker()方法来执行任务，我们来看一下这个方法的源码：

final void runWorker(Worker w) {
    // 获取当前工作线程
    Thread wt = Thread.currentThread();
    
    // 从 Worker 中取出第一个任务
    Runnable task = w.firstTask;
    w.firstTask = null;
    
    // 解锁 Worker（允许中断）
    w.unlock(); 
    
    boolean completedAbruptly = true;
    try {
        // 当有任务需要执行或者能够从任务队列中获取到任务时，工作线程就会持续运行
        while (task != null || (task = getTask()) != null) {
            // 锁定 Worker，确保在执行任务期间不会被其他线程干扰
            w.lock();
            
            // 如果线程池正在停止，并确保线程已经中断
            // 如果线程没有中断并且线程池已经达到停止状态，中断线程
            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++;
                // 解锁 Worker
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        // 工作线程退出的后续处理
        processWorkerExit(w, completedAbruptly);
    }
}

在这段源码中我们看到了线程被复用的原因了，就是这个while的循环，当有任务需要执行或者能够从任务队列中获取到任务时，工作线程就会持续运行；如果从 getTask 获取不到方法的话，就会调用 finally 中的 processWorkerExit 方法，将线程退出。

十二：线程池中的阻塞队列有哪些

常见的阻塞队列有以下几种

// 1、无界队列 LinkedBlockingQueue，容量Integer.MAX_VALUE
public static ExecutorService newFixedThreadPool(int nThreads) {
 
    return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
 
}
 
// 1、无界队列 LinkedBlockingQueue
public static ExecutorService newSingleThreadExecutor() {
 
    return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
 
}
 
// 2、同步队列 SynchronousQueue，没有容量，不存储元素，目的是保证对于提交的任务，如果有空闲线程，则使用空闲线程来处理；否则新建一个线程来处理任务，因此线程最多可创建Integer.MAX_VALUE个。
public static ExecutorService newCachedThreadPool() {
 
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
 
}
 
// 3、DelayedWorkQueue（延迟阻塞队列），添加元素满了之后会自动扩容原来容量的 1/2，即永远不会阻塞，最大扩容可达 Integer.MAX_VALUE。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

十三：线程池中的任务出现异常后，是复用还是销毁呢

这个问题我们要分两种情况去分析，第一种是通过 execute() 提交任务时，在执行过程中抛出异常，且没有在任务内被捕获，当前线程会因此终止，异常信息会记录在日志或控制台中，并且线程池会移除异常线程，重新创建一个线程补上去。

第二种通过submit()提交任务时，如果在任务执行中发生异常，这个异常不会直接打印出来。相反，异常会被封装在由submit()返回的Future对象中。当调用Future.get()方法时，可以捕获到一个ExecutionException。在这种情况下，线程不会因为异常而终止，它会继续存在于线程池中，准备执行后续的任务。

通过submit()的底层源码发现，其实它的内部封装的是execute方法，只不过它的任务被放在了RunnableFuture对象里。

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

execute方法会抛出异常终止线程的，为什么submit中不会呢，那么肯定在RunnableFuture里，经过一顿跟踪发现，这个Future中实现的run方法，对异常进行了捕获，所以并不会往上抛出，也就不会移除异常线程以及新建线程了。

十四：如何关闭一个线程池

在JDK 1.8 中，线程池的停止一般使用 shutdown()、shutdownNow()这两种方法。

1.shutdown

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock; // ThreadPoolExecutor的主锁
    mainLock.lock(); // 加锁以确保独占访问
 
    try {
        checkShutdownAccess(); // 检查是否有关闭的权限
        advanceRunState(SHUTDOWN); // 将执行器的状态更新为SHUTDOWN
        interruptIdleWorkers(); // 中断所有闲置的工作线程
        onShutdown(); // ScheduledThreadPoolExecutor中的挂钩方法，可供子类重写以进行额外操作
    } finally {
        mainLock.unlock(); // 无论try块如何退出都要释放锁
    }
    tryTerminate(); // 如果条件允许，尝试终止执行器
}

在shutdown的源码中，会启动一次顺序关闭，在这次关闭中，执行器不再接受新任务，但会继续处理队列中的已存在任务，当所有任务都完成后，线程池中的线程会逐渐退出。

2.shutdownNow

public List<Runnable> shutdownNow() {
    List<Runnable> tasks; // 用于存储未执行的任务的列表
    final ReentrantLock mainLock = this.mainLock; // ThreadPoolExecutor的主锁
    mainLock.lock(); // 加锁以确保独占访问
    try {
        checkShutdownAccess(); // 检查是否有关闭的权限
        advanceRunState(STOP); // 将执行器的状态更新为STOP
        interruptWorkers(); // 中断所有工作线程
        tasks = drainQueue(); // 清空队列并将结果放入任务列表中
    } finally {
        mainLock.unlock(); // 无论try块如何退出都要释放锁
    }
    tryTerminate(); // 如果条件允许，尝试终止执行器
    return tasks; // 返回队列中未被执行的任务列表
}

与shutdown不同的是shutdownNow会尝试终止所有的正在执行的任务，清空队列，停止失败会抛出异常，并且返回未被执行的任务列表。

线程池夺命十四问