定时周期延时线程池：ScheduledThreadPoolExecutor

最新推荐文章于 2024-07-17 09:30:13 发布

Dominic_zjt

最新推荐文章于 2024-07-17 09:30:13 发布

阅读量706

点赞数

分类专栏： java 文章标签： java 多线程

原文链接：https://www.jianshu.com/p/5d994ee6d4ff

版权

java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

转载地址：
https://www.jianshu.com/p/c41e942bcd64
转载地址：
https://www.jianshu.com/p/502f9952c09b
一.ThreadPoolExecutor概述
线程池解决了两个不同问题：
1.性能提升：他们通常在执行大量异步任务时，减少了线程的创建开销，使性能得到了提升。
2.统计信息：可以统计完成的任务数量

线程池的构造方法有四种：
其中最全的一个是

public ThreadPoolExecutor(int corePoolSize,
            　　　　　　　　 int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
　　　　　　　　　　　　　　　 ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

}

1.corepoolsize和maximumpoolsize
其中corepoolsize是线程池核心线程数
maximumpoolsize 是线程池最大线程数
具体的：当接收到一个任务时，当前的线程数少于corepoolsize的大小，无论是否空闲线程都会启动一个新的线程来执行任务。
如果有多与corepoolsize但小于maximumpoolsize 的线程正在运行，则当前队列满时才会创建一个新的线程执行任务，

2.prestartCoreThread 核心线程预启动
prestartCoreThread() 创一个空闲任务线程等待任务的到达
prestartAllCoreThreads() 创建核心线程池数量的空闲任务线程等待任务的到达

3.ThreadFactory 线程工厂
新线程使用ThreadFactory创建。

4.Keep-alive times 线程存活时间
如果当前持有的线程多于corepoolsize多余的线程在空余时间超过Keep-alive times后就会被终止。
注：默认情况下，keep-alive策略仅适用于存在超过corePoolSize线程的情况。但是，只要keepAliveTime值不为零，方法allowCoreThreadTimeOut(boolean)也可用于将此超时策略应用于核心线程。

5.Queuing 队列
BlockingQueu用于存放提交的任务，队列的实际容量与线程池大小相关联。
主要有三种队列策略：

⑴Direct handoffs 直接握手队列
Direct handoffs 的一个很好的默认选择是 SynchronousQueue，它将任务交给线程而不需要保留。这里，如果没有线程立即可用来运行它，那么排队任务的尝试将失败，因此将构建新的线程。
此策略在处理可能具有内部依赖关系的请求集时避免锁定。Direct handoffs 通常需要无限制的maximumPoolSizes来避免拒绝新提交的任务。但得注意，当任务持续以平均提交速度大余平均处理速度时，会导致线程数量会无限增长问题。

⑵Unbounded queues 无界队列
当所有corePoolSize线程繁忙时，使用无界队列（例如，没有预定义容量的LinkedBlockingQueue）将导致新任务在队列中等待，从而导致maximumPoolSize的值没有任何作用。当每个任务互不影响，完全独立于其他任务时，这可能是合适的; 例如，在网页服务器中，这种队列方式可以用于平滑瞬时大量请求。但得注意，当任务持续以平均提交速度大余平均处理速度时，会导致队列无限增长问题。

⑶Bounded queues 有界队列
一个有界的队列（例如，一个ArrayBlockingQueue）和有限的maximumPoolSizes配置有助于防止资源耗尽，但是难以控制。队列大小和maximumPoolSizes需要相互权衡：

使用大队列和较小的maximumPoolSizes可以最大限度地减少CPU使用率，操作系统资源和上下文切换开销，但会导致人为的低吞吐量。如果任务经常被阻塞（比如I/O限制），那么系统可以调度比我们允许的更多的线程。
使用小队列通常需要较大的maximumPoolSizes，这会使CPU更繁忙，但可能会遇到不可接受的调度开销，这也会降低吞吐量。

6.Rejected tasks 拒绝任务
拒绝任务有两种情况：1. 线程池已经被关闭；2. 任务队列已满且maximumPoolSizes已满；
无论哪种情况，都会调用RejectedExecutionHandler的rejectedExecution方法。

二.ScheduledThreadPoolExecutor
构造方法：

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

public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue(), threadFactory);
}；
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   RejectedExecutionHandler handler) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue(), handler);
}；

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

特有方法：
ScheduledThreadPoolExecutor实现了ScheduledExecutorService接口，该接口定义了可延时执行异步任务和可周期执行异步任务的特有功能，相应的方法分别为：

//达到给定的延时时间后，执行任务。这里传入的是实现Runnable接口的任务，
//因此通过ScheduledFuture.get()获取结果为null
public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);
//达到给定的延时时间后，执行任务。这里传入的是实现Callable接口的任务，
//因此，返回的是任务的最终计算结果
 public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

//是以上一个任务开始的时间计时，period时间过去后，
//检测上一个任务是否执行完毕，如果上一个任务执行完毕，
//则当前任务立即执行，如果上一个任务没有执行完毕，则需要等上一个任务执行完毕后立即执行
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
//当达到延时时间initialDelay后，任务开始执行。上一个任务执行结束后到下一次
//任务执行，中间延时时间间隔为delay。以这种方式，周期性执行任务。
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);