ThreadPoolExecutor - 管理线程池的核心类

重剑DS2024-07-07 15:59

下面是使用给定的初始参数创建一个新的 ThreadPoolExecutor （构造方法）。

java 复制代码 
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

形参:

  • corePoolSize -- 要保留在池中的线程数，即使它们处于空闲状态，除非 allowCoreThreadTimeOut 被设置了。
    allowCoreThreadTimeOut 是一个开关，用于控制核心线程是否可以在空闲状态下超时并被终止。默认情况下，allowCoreThreadTimeOut 是 false，这意味着核心线程不会因为空闲而超时被销毁。如果你调用
    setAllowCoreThreadTimeOut(true)，那么核心线程也会像非核心线程一样，在空闲一段时间后（由
    keepAliveTime 和 unit 参数指定）被终止。
  • maximumPoolSize -- 池中允许的最大线程数
  • keepAliveTime -- 当线程数大于核心数时，这是多余的空闲线程在终止之前等待新任务的最长时间。
  • unit -- 参数的时间 keepAliveTime 单位
  • workQueue -- 用于在任务执行之前保存任务的队列。这个队列将仅保存通过 execute 方法提交的 Runnable 任务和通过
    submit 方法提交的 Runnable 或 Callable 任务。 execute 方法只接受 Runnable 任务。execute 方法没有返回值。适用于不需要返回结果的任务。
    submit 方法可以接受 Runnable 或 Callable 任务。submit 方法返回一个 Future 对象。
    如果提交的是 Runnable 任务，Future.get() 方法返回 null。
    如果提交的是 Callable 任务，Future.get() 方法返回 call 方法的返回值。
    适用于需要返回结果或检查任务状态的任务。
  • threadFactory -- 执行器创建新线程时使用的工厂
  • handler -- 当线程边界和队列容量已达到上限导致执行被阻塞时使用的处理程序。 handler 是
    RejectedExecutionHandler 接口的实现类对象。


RejectedExecutionHandler 接口的 rejectedExecution() 方法一共有四种默认实现：

  1. AbortPolicy - Abort 意思为中止
  • 类名：java.util.concurrent.ThreadPoolExecutor.AbortPolicy
  • 描述：这种策略在任务不能被执行时，会抛出 RejectedExecutionException 异常。它是默认的拒绝策略。
    使用场景：适用于不能丢弃任务且需要立即知道任务被拒绝的情况。
java 复制代码 
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}
  1. CallerRunsPolicy
  • 类名：java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy
  • 描述：这种策略在任务不能被执行时，会由提交任务的线程（通常是调用 execute 方法的线程）来执行该任务。这种策略可以有效降低新任务的流量，避免任务丢失。
    使用场景：适用于可以接受任务执行延迟但不希望任务被丢弃的情况。
java 复制代码 
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}
  1. DiscardOldestPolicy
  • 类名：java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy
  • 描述：这种策略在任务不能被执行时，会丢弃队列中最旧的未处理任务，然后尝试重新提交被拒绝的任务。
    使用场景：适用于希望优先处理新任务 而可以接受丢弃旧任务的情况。
java 复制代码 
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}
  1. DiscardPolicy
  • 类名：java.util.concurrent.ThreadPoolExecutor.DiscardPolicy
  • 描述：这种策略在任务不能被执行时，会直接丢弃被拒绝的任务，不会有任何异常抛出。
    使用场景：适用于可以接受任务丢弃且不希望处理被拒绝任务的情况。
java 复制代码 
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }

    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        // Do nothing
    }
}

总结：

  • AbortPolicy：直接抛出 RejectedExecutionException 异常。
  • CallerRunsPolicy：由提交任务的线程执行被拒绝的任务。
  • DiscardOldestPolicy：丢弃队列中最旧的任务，然后重新提交被拒绝的任务。
  • DiscardPolicy：直接丢弃被拒绝的任务，不抛出异常。

下面是四种对于上述的ThreadPoolExecutor的封装，ExecutorService是线程服务对象

  1. 创建固定数量的线程对象newFixedThreadPool()
java 复制代码 
ExecutorService executorService = Executors.newFixedThreadPool(3);
java 复制代码 
    /**
	创建一个线程池，该线程池重用在共享的无界队列上运行的固定数量的线程。在任何时候，大多数 nThreads 线程都将是活动的去处理任务。
	如果在所有线程都处于活动状态时提交了其他任务，它们将在队列中等待，直到线程可用。
	如果某个线程在关闭之前由于执行期间的故障而终止，那么如果需要执行后续任务，将会有一个新的线程替代它的位置。
	这段话解释了固定大小线程池的一个重要特性：线程池会维护固定数量的线程，即使其中某个线程由于运行时的异常或错误而终止，线程池也会创建一个新的线程来替换它，从而确保线程池中始终有固定数量的线程来处理任务。
		形参:
		nThreads -- 池中的线程数
		返回值:
		新创建的线程池
		抛出:
		IllegalArgumentException --如果 nThreads <= 0
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS, // 毫秒
                                      new LinkedBlockingQueue<Runnable>());
    }

ThreadPoolExecutor(nThreads)

核心线程数：nThreads

最大线程数：nThreads

队列类型：LinkedBlockingQueue（无界队列）FIFO先进先出队列

行为：固定数量的线程处理任务。如果所有线程都在忙碌，新任务会被放入无界队列中等待。

适用场景：适用于需要稳定的线程数量来处理较为均匀的任务负载的场景。

  1. 根据需求动态创建线程newCachedThreadPool, 创建的线程可以重复使用，只是当目前线程不够了他会动态增加线程
java 复制代码 
ExecutorService executorService = Executors.newCachedThreadPool();
java 复制代码 
/*
创建一个可以根据需要创建新线程的线程池，但如果之前构造的线程可用，则会重用这些线程。
这种线程池通常会提升那些执行许多短暂异步任务的程序的性能。
调用 execute 方法时，如果有可用的线程，会重用之前构造的线程。如果没有可用的线程，则会创建一个新线程并添加到线程池中。

未使用超过60秒的线程会被终止并从缓存中移除。
因此，一个长时间处于空闲状态的线程池将不会消耗任何资源。
需要注意的是，可以使用 ThreadPoolExecutor 构造函数创建具有类似属性但不同细节（例如超时参数）的线程池。

返回值:
新创建的线程池
*/
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

newCachedThreadPool()

核心线程数：0

最大线程数：Integer.MAX_VALUE

队列类型：SynchronousQueue（不存储任务的队列，每次插入操作都必须等待对应的删除操作，反之亦然）。

每个 put 操作（插入任务）必须等待一个 take 操作（移除任务），相应地，每个 take 操作必须等待一个 put 操作。换句话说，生产者线程和消费者线程必须直接在队列上进行任务的交接。

行为：线程池可根据需求动态创建新线程，闲置超过 60 秒的线程会被终止并移出缓存。

适用场景：适用于大量短期异步任务或任务负载波动较大的场景。

newCachedThreadPool() 的工作原理：

① 任务提交：

当一个任务被提交到 newCachedThreadPool() 时，它会尝试将任务放入 SynchronousQueue。

由于 SynchronousQueue 不存储任务，这意味着必须有一个线程立即接收这个任务。

② 线程创建：

如果当前没有空闲线程能够立即接收任务，newCachedThreadPool() 会创建一个新的线程来处理这个任务。

这种机制确保了任务可以尽快得到处理。

③ 线程回收：

新创建的线程如果在闲置超过 60 秒后没有接收到新的任务，就会被终止并移出线程池。

这有助于释放资源，避免不必要的线程占用。

newCachedThreadPool() 完全依赖非核心线程来处理任务

  1. 单一线程newSingleThreadExecutor
java 复制代码 
ExecutorService executorService = Executors.newSingleThreadExecutor();
java 复制代码 
/*
创建一个 Executor，它使用单个工作线程从一个无界队列中获取任务进行操作。
（但是请注意，如果这个单个线程在执行过程中因为故障而在关闭之前终止了，那么如果需要执行后续任务，将会有一个新的线程替代它的位置。）
任务保证按顺序执行，并且在任何给定时间点，不会有超过一个任务在运行。
与功能相似的 newFixedThreadPool(1) 不同，返回的执行器保证不会被重新配置为使用额外的线程。

返回值:
新创建的单线程执行器
*/
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS, // 毫秒
                                    new LinkedBlockingQueue<Runnable>()));
    }
java 复制代码 
private static class FinalizableDelegatedExecutorService
            extends DelegatedExecutorService {
        FinalizableDelegatedExecutorService(ExecutorService executor) {
            super(executor);
        }
        @SuppressWarnings("deprecation")
        protected void finalize() {
            super.shutdown();
        }
    }
java 复制代码 
private static class DelegatedExecutorService
            implements ExecutorService {
        private final ExecutorService e;
        DelegatedExecutorService(ExecutorService executor) { e = executor; }

newSingleThreadExecutor()

核心线程数：1

最大线程数：1

队列类型：LinkedBlockingQueue（无界队列）

行为：始终只有一个线程执行任务，任务按提交顺序执行。如果线程因故障终止，会创建一个新线程来替代它。

适用场景：适用于需要按顺序执行任务的场景，并且在同一时间只需要一个线程执行任务。

newFixedThreadPool(1)：虽然初始时只有一个线程，但它是使用 ThreadPoolExecutor 实现的，理论上可以通过调用 setCorePoolSize 和 setMaximumPoolSize 方法来重新配置线程池的线程数量。

也就是说，虽然默认情况下只有一个线程，但你可以在运行时增加线程池中的线程数量。
newSingleThreadExecutor()：这个执行器保证始终只有一个线程，无法通过重新配置来增加线程数量。

它的实现确保了线程池的单线程性质是不可更改的。

  1. 定时调度线程 newScheduledThreadPool, 线程有3个，但是线程在什么时候执行我们可以去定义他
java 复制代码 
ExecutorService executorService = Executors.newScheduledThreadPool(3);
java 复制代码 
/*
	创建一个线程池，该线程池可以计划命令在给定延迟后运行，或定期执行。
	形参:
	corePoolSize -- 池中要保留的线程数，即使它们处于空闲状态
	返回值:
	新创建的定时线程池
	抛出:
	IllegalArgumentException --如果 corePoolSize < 0
*/
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
java 复制代码 
public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {
/*
	使用给定的核心池大小创建一个新 ScheduledThreadPoolExecutor 池。
	形参:
	corePoolSize -- 要保留在池中的线程数，即使它们处于空闲状态，除非 allowCoreThreadTimeOut 已设置
	抛出:
	IllegalArgumentException --如果 corePoolSize < 0
*/
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,  // DEFAULT_KEEPALIVE_MILLIS = 10L
              new DelayedWorkQueue());  
        // super父类对象是ThreadPoolExecutor
        // 相当于：
        // public ThreadPoolExecutor(int corePoolSize,
        //                      int maximumPoolSize,
       //                       long keepAliveTime,
        //                      TimeUnit unit,
        //                      BlockingQueue<Runnable> workQueue) {
       // this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
       //      Executors.defaultThreadFactory(), defaultHandler);
    }
    }
 
 }

newScheduledThreadPool(int corePoolSize) 方法用于创建一个定时线程池。
ScheduledThreadPoolExecutor 类继承自 ThreadPoolExecutor，并添加了对定时任务的支持。

核心线程数由 corePoolSize 决定，最大线程数为 Integer.MAX_VALUE。

非核心线程的默认存活时间是 10 毫秒。

无界队列：DelayedWorkQueue 是一个无界队列，适用于存储定时任务和周期性任务。即使队列是无界的，它主要是一个优先级队列（基于任务的预定执行时间），并且不会因为任务太多而导致线程池拒绝任务。

超出线程池和等待队列容量的任务会被拒绝，并抛出异常。

newScheduledThreadPool(corePoolSize)

核心线程数：corePoolSize

最大线程数：Integer.MAX_VALUE

队列类型：DelayedWorkQueue（无界优先级队列，基于任务的预定执行时间）

行为：支持定时任务和周期性任务的线程池，核心线程数由 corePoolSize 决定，超出线程池和等待队列容量的任务会被拒绝并抛出异常。线程池可根据需求动态创建新的非核心线程，闲置超过 10 毫秒的线程会被终止并移出缓存，虽然话是这么说，但是由于 DelayedWorkQueue 是一个无界队列，通常情况下不会出现任务队列满的情况，因此非核心线程在 ScheduledThreadPoolExecutor 中被使用的机会较少，就主要还是依赖corePoolSize指定的核心线程来运行任务。因为核心线程先处理不完，然后把任务放到等待队列，等待队列也满了才开非核心线程，我是这样理解的。

适用场景：适用于需要在特定时间点或周期性执行任务的场景。

相关推荐
金灰2 分钟前
HTML5--裸体回顾
java·开发语言·前端·javascript·html·html5
菜鸟一皓3 分钟前
IDEA的lombok插件不生效了？！！
java·ide·intellij-idea
爱上语文6 分钟前
Java LeetCode每日一题
java·开发语言·leetcode
bug菌29 分钟前
Java GUI编程进阶：多线程与并发处理的实战指南
java·后端·java ee
程序猿小D42 分钟前
第二百六十九节 JPA教程 - JPA查询OrderBy两个属性示例
java·开发语言·数据库·windows·jpa
极客先躯2 小时前
高级java每日一道面试题-2024年10月3日-分布式篇-分布式系统中的容错策略都有哪些？
java·分布式·版本控制·共识算法·超时重试·心跳检测·容错策略
夜月行者2 小时前
如何使用ssm实现基于SSM的宠物服务平台的设计与实现+vue
java·后端·ssm
程序猿小D2 小时前
第二百六十七节 JPA教程 - JPA查询AND条件示例
java·开发语言·前端·数据库·windows·python·jpa
潘多编程2 小时前
Java中的状态机实现：使用Spring State Machine管理复杂状态流转
java·开发语言·spring
_阿伟_3 小时前
SpringMVC
java·spring
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache