Java并发42:Executor系列--Executors(下)-几类预定义的线程池ExecutorService和可调度线程池ScheduledExecutorService

最新推荐文章于 2023-07-12 15:24:42 发布
最新推荐文章于 2023-07-12 15:24:42 发布
阅读量1.2k 收藏
点赞数 2
分类专栏： Java并发 Java并发学习实例 文章标签： ExecutorService ScheduleExecutorService ThreadPoolExecutor ScheduleThreadPoolExecutor 代理防止修改
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanchao5272/article/details/79840138
版权

[超级链接：Java并发学习系列-绪论]

本章继续学习Executors工具类。

1.Executors接口概述

@since 1.5

这个类定义了供Executor、ExecutorService、ScheduledExecutorService、ThreadFactory和Callable这些接口和类使用的工厂方法和工具方法。

Executors来自java.util.concurrent，是Executor并发框架的主要工具类。

Executors提供了以下几类方法：

  • 第1类静态方法：将Runnable转换成Callable。
  • 第2类静态方法：线程工厂(ThreadFactory)类。
  • 第3类静态方法：实例化几类不可配置的线程池(ExecutorService和ScheduleExecutorService)。
  • 第4类静态方法：实例化几类预先配置的常用线程池(ExecutorService)。
  • 第5类静态方法：实例化几类预先配置的常用可调度线程池(ScheduleExecutorService)。

本章主要对第4、5类静态方法进行说说明。

2.第4类静态方法：几类预先配置的常用线程池

Executors通过静态方法提供以下几类预先配置的常用线程池：

2.1.newSingleThreadExecutor - 单任务线程池
  • 使用一个单独的工作线程和无界工作队列的线程池。
  • 需要注意的是：如果这个工作线程在关闭之前因为执行失败而终止，则如果需要去执行后续任务，可以新建一个线程代替它。
  • 任务是按顺序执行的，任意时刻，都不会有超过一个以上的活动线程。
  • 不同于等效的newFixedThreadPool(1)，newSingleThreadExecutor不能通过配置而达到使用额外线程的目的。

方法定义：

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

从方法定义可知：

  • 其实际是通过ThreadPoolExecutor构造的。
  • 使用了代理类FinalizableDelegatedExecutorService，使之无法修改配置。

参数说明

  • corePoolSize = 1 --> 1.至多只有一个活动线程会长期存在
  • maximumPoolSize = 1 --> 3.因为无界队列，此参数无实际意义
  • keepAliveTime = 0L --> 4.因为无界队列，此参数无实际意义
  • TimeUnit = TimeUnit.MILLISECONDS --> 4.因为无界队列，此参数无实际意义
  • workQueue = new LinkedBlockingQueue<Runnable>()) --> 2.无界队列，如果无可用核心线程，则新任务在此等待，不会再创建线程

实例代码：

System.out.println("===================== newSingleThreadExecutor - 单任务线程池");
//定义一个单任务线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
//循环执行5个任务
for (int i = 0; i < 5; i++) {
    //永远都是thread-1
    singleThreadExecutor.submit(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}
Thread.sleep(1000);
singleThreadExecutor.shutdown();
System.out.println("===================== newSingleThreadExecutor - 单任务线程池");

运行结果：

===================== newSingleThreadExecutor - 单任务线程池
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
===================== newSingleThreadExecutor - 单任务线程池

结果说明：

从运行结果可知，无论向线程池中提交多少任务，其内只是pool-1-thread-1这个线程在执行。

2.2.newCachedThreadPool - 缓存线程池
  • 创建一个线程池，这个线程池能够按需创建新线程，并且能够重用的之前创建的可用线程。
  • 这个线程池会典型的提高处理多个短期异步任务的程序的新能。
  • 如果有可用的线程，执行任务会尽量重用以前构建的线程。
  • 如果没有可用的线程，将会创建一个新的线程，并将此线程添加到线程池中。
  • 空闲超过60秒的线程将会被终止，并且从缓存中移除。
  • 因此，即使这个线程池空闲再长时间，也不会消耗任何资源。
  • 注意，可以通过ThreadPoolExecutor的构造函数，构造具有相似属性不同细节(例如：超时参数)的缓存线程池实现。

方法定义：

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

从方法定义可知：

  • 其实际是通过ThreadPoolExecutor构造的。

参数说明：

  • corePoolSize = 0 --> 1.不会存在长期存在的线程
  • maximumPoolSize = Integer.MAX_VALUE --> 3.最多创建2,147,483,647个线程
  • keepAliveTime = 60L --> 4.线程执行完任务后，最多空闲60秒，就会关闭
  • TimeUnit = TimeUnit.SECONDS --> 4.线程执行完任务后，最多空闲60秒，就会关闭
  • workQueue = new SynchronousQueue<Runnable>() --> 2.直传队列，新线程到达，不会等待，会直接创建新线程

实例代码：

System.out.println("===================== newCachedThreadPool - 缓存线程池");
//定义一个缓冲线程池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
//创建5个线程
for (int i = 0; i < 5; i++) {
    //如果无可用线程，则创建新线程
    cachedThreadPool.submit(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}
//等待1秒
Thread.sleep(1000);
System.out.println();
//再次重新创建5个线程
for (int i = 0; i < 5; i++) {
    //如果有可用线程，则重用之前创建的线程
    cachedThreadPool.submit(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}
//等待1秒
Thread.sleep(70000);
System.out.println();
//再次重新创建5个线程
for (int i = 0; i < 5; i++) {
    //如果有可用线程，则重用之前创建的线程
    cachedThreadPool.submit(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}
Thread.sleep(1000);
cachedThreadPool.shutdown();
System.out.println("===================== newCachedThreadPool - 缓存线程池")

运行结果：

===================== newCachedThreadPool - 缓存线程池
pool-2-thread-1
pool-2-thread-3
pool-2-thread-4
pool-2-thread-5
pool-2-thread-2

pool-2-thread-3
pool-2-thread-4
pool-2-thread-1
pool-2-thread-2
pool-2-thread-5

pool-2-thread-6
pool-2-thread-7
pool-2-thread-8
pool-2-thread-9
pool-2-thread-10
===================== newCachedThreadPool - 缓存线程池

结果说明：

  • 当无可用的空闲线程时，线程池会创建新的线程来执行新的任务。
  • 当有可用的空闲线程时，线程池会优先使用之前创建的线程来执行新的任务。
  • 线程的空闲时间超过60秒，就会关闭；这时再进来新的任务，线程池又会创建新线程来执行任务。
2.3.newFixedThreadPool - 固定大小线程池
  • 创建一个线程池，这个线程池重复使用固定数量的线程池，以及一个共享的无界队列。
  • 在任何时候，最多有nThreads个活动的线程。
  • 如果所有的nThreads个线程都处于活动状态，则新提交的任务将会在队列中等待。
  • 如果一个工作线程在关闭之前因为执行失败而终止，则如果需要去执行后续任务，可以新建一个线程代替它。
  • 线程池中的线程会一直存在，直到显式的调用关闭方法shutdown或shutdownNow。

方法定义：

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

从方法定义可知：

  • 其实际是通过ThreadPoolExecutor构造的。

参数说明：

  • corePoolSize = nThreads --> 1.至多有nThreads个活动线程会长期存在
  • maximumPoolSize = nThreads --> 3.因为无界队列，此参数无实际意义
  • keepAliveTime = 0L --> 4.因为无界队列，此参数无实际意义
  • TimeUnit = TimeUnit.MILLISECOND --> 4.因为无界队列，此参数无实际意义
  • workQueue = new LinkedBlockedQueue<Runnable>()> --> 2.无界队列，如果无可用核心线程，则新任务在此等待，不会再创建线程

实例代码：

System.out.println("===================== newFixedThreadPool - 固定大小线程池");
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);
for (int i = 0; i < 5; i++) {
    //在thread-1 和 Thread-2 之间切换
    fixedThreadPool.submit(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}
Thread.sleep(1000);
fixedThreadPool.shutdown();
System.out.println("===================== newFixedThreadPool - 固定大小线程池");

运行结果：

===================== newFixedThreadPool - 固定大小线程池
pool-3-thread-1
pool-3-thread-2
pool-3-thread-1
pool-3-thread-2
pool-3-thread-1
===================== newFixedThreadPool - 固定大小线程池

结果说明：

从运行结果可知，无论向线程池中提交多少任务，其内只有2个线程在执行。

2.4.newWorkStealingPool - 并行工作者线程池
  • 创建一个工作窃取线程池，以JVM运行时可以CPU核数作为线程池的并行度。
  • 此线程池通过ForkJoinPool实现。

方法定义：

public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool
        (Runtime.getRuntime().availableProcessors(),
         ForkJoinPool.defaultForkJoinWorkerThreadFactory,
         null, true);
}

参数说明：

  • parallelism = Runtime.getRuntime().availableProcessors() --> 1.并行级别为运行期可用的CPU处理器数量
  • factory = ForkJoinPool.defaultForkJoinWorkerThreadFactory --> 2.使用ForkJoinPool默认的工作线程队列
  • handler = null --> 3.不设置异常捕捉处理器
  • asyncMode = true --> 4.采取异步模式

实例代码：

System.out.println("===================== newWorkStealingPool - 并行任务线程池");
//定义一个并行工作者线程池
ExecutorService workStealingPool = Executors.newWorkStealingPool();
//循环创建线程池
for (int i = 0; i < 20; i++) {
    //因为本机CPU为4核，所以并行级别为4，即最多平行四个工作者。
    workStealingPool.submit(() -> {
        System.out.println(Thread.currentThread().getName());
    });
}
//
Thread.sleep(1000);
workStealingPool.shutdown();
System.out.println("===================== newWorkStealingPool - 并行任务线程池");

运行结果：

===================== newWorkStealingPool - 并行任务线程池
ForkJoinPool-1-worker-1
ForkJoinPool-1-worker-2
ForkJoinPool-1-worker-1
ForkJoinPool-1-worker-1
ForkJoinPool-1-worker-1
ForkJoinPool-1-worker-1
ForkJoinPool-1-worker-2
ForkJoinPool-1-worker-2
ForkJoinPool-1-worker-2
ForkJoinPool-1-worker-2
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-3
ForkJoinPool-1-worker-0
ForkJoinPool-1-worker-1
ForkJoinPool-1-worker-2
===================== newWorkStealingPool - 并行任务线程池

结果说明：

因为本机CPU为4核，所以并行级别为4，即最多平行四个工作者。

3.第5类静态方法：几类预先配置的常用可调度线程池

Executors通过静态方法提供以下几类预先配置的常用可调度线程池：

3.1.newScheduledThreadPool - 固定大小调度线程池
  • 创建一个线程池，这个线程池可以延时执行任务，或者周期性的执行任务。

方法定义：

//Executors
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
//ScheduledThreadPoolExecutor
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}
//ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

从方法定义可知：

  • 其实际是通过ScheduledThreadPoolExecutor构造的.
  • 而ScheduledThreadPoolExecutor是通过ThreadPoolExecutor构造的。

参数说明：

  • corePoolSize = 指定大小 --> 1.至多有指定数量的活动线程会长期存在
  • maximumPoolSize = Integer.MAX_VALUE --> 3.因为无界队里，此参数无实际意义
  • keepAliveTime = 0L --> 4.因为无界队列，此参数无实际意义
  • TimeUnit = TimeUnit.NANOSECONDS --> 4.因为无界队列，此参数无实际意义
  • workQueue = new DelayedWorkQueue() --> 2.一种无界队列，如果无可用核心线程，则新任务在此等待，不会再创建线程

实例代码：

 System.out.println("===================== newScheduledThreadPool - 调度线程池");
//定义一个固定大小的调度线程池
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
//循环提交任务
for (int i = 0; i < 5; i++) {
    //在thread-1 和 Thread-2 之间切换
    //如果不能计算好线程池的核心线程数量和任务延时之间的关系，很可能造成指定的延时任务并未按照计划执行
    scheduledThreadPool.schedule(() -> {
        System.out.println(Thread.currentThread().getName() + " begin... ");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " end. ");
    }, 2, TimeUnit.SECONDS);
}
Thread.sleep(7000);
System.out.println("===================== newScheduledThreadPool - 调度线程池");
scheduledThreadPool.shutdown();

运行结果：

===================== newScheduledThreadPool - 调度线程池
pool-4-thread-2 begin... 
pool-4-thread-1 begin... 
pool-4-thread-2 end. 
pool-4-thread-2 begin... 
pool-4-thread-1 end. 
pool-4-thread-1 begin... 
pool-4-thread-2 end. 
pool-4-thread-2 begin... 
pool-4-thread-1 end. 
pool-4-thread-2 end. 
===================== newScheduledThreadPool - 调度线程池

结果说明：

  • 这些任务都在2秒之后才开始执行。
  • 这些任务只会通过pool-4-thread-1和pool-4-thread-2这两个工作线程执行。
3.2.newSingleThreadScheduledExecutor - 单线程的调度线程池
  • 创建一个单线程线程池，这个线程池可以延时执行任务，或者周期性的执行任务。
  • 但是请注意，如果这个工作线程在关闭之前因为执行失败而终止，则如果需要去执行后续任务，可以新建一个线程代替它。
  • 任务是按顺序执行的，任意时刻，都不会有超过一个以上的活动线程。
  • 不同于等效的newScheduledThreadPool(1)，newSingleThreadScheduledExecutor不能通过配置而达到使用额外线程的目的。

方法定义：

//Executors
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
    return new DelegatedScheduledExecutorService
        (new ScheduledThreadPoolExecutor(1));
}
//Executors
DelegatedScheduledExecutorService(ScheduledExecutorService executor) {
    super(executor);
    e = executor;
}
//Executors
DelegatedExecutorService(ExecutorService executor) { e = executor; }
//ScheduledThreadPoolExecutor
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}
//ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

从方法定义可知：

  • 使用了代理类DelegatedScheduledExecutorService，使之无法修改配置。
  • 其实际是通过ScheduledThreadPoolExecutor构造的.
  • 而ScheduledThreadPoolExecutor是通过ThreadPoolExecutor构造的。

参数说明：

  • corePoolSize = 1 --> 1.至多只有1个的活动线程会长期存在
  • maximumPoolSize = Integer.MAX_VALUE --> 3.因为无界队里，此参数无实际意义
  • keepAliveTime = 0L --> 4.因为无界队列，此参数无实际意义
  • TimeUnit = TimeUnit.NANOSECONDS --> 4.因为无界队列，此参数无实际意义
  • workQueue = new DelayedWorkQueue() --> 2.一种无界队列，如果无可用核心线程，则新任务在此等待，不会再创建线程

实例代码：

System.out.println("===================== newSingleThreadScheduledExecutor - 单线程的调度线程池");
//定义一个单线程的调度线程池
ScheduledExecutorService singleThreadScheduledExecutor = Executors.newSingleThreadScheduledExecutor();
for (int i = 0; i < 5; i++) {
    singleThreadScheduledExecutor.schedule(() -> {
        System.out.println(Thread.currentThread().getName() + " begin... ");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " end. ");
    }, 2, TimeUnit.SECONDS);
}
Thread.sleep(10000);
System.out.println("===================== newSingleThreadScheduledExecutor - 单线程的调度线程池");
singleThreadScheduledExecutor.shutdown();

运行结果：

===================== newSingleThreadScheduledExecutor - 单线程的调度线程池
pool-5-thread-1 begin... 
pool-5-thread-1 end. 
pool-5-thread-1 begin... 
pool-5-thread-1 end. 
pool-5-thread-1 begin... 
pool-5-thread-1 end. 
pool-5-thread-1 begin... 
pool-5-thread-1 end. 
pool-5-thread-1 begin... 
pool-5-thread-1 end. 
===================== newSingleThreadScheduledExecutor - 单线程的调度线程池

结果说明：

  • 这些任务都在2秒之后才开始执行。
  • 这些任务只会通过pool-4-thread-1这1个工作线程执行。
hanchao5272
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java并发编程：Executor、Executors、ExecutorService.docx
06-21
Executor： 一个接口，其定义了一个接收Runnable对象的方法executor，其方法签名为executor(Runnable command),该方法接收一个Runable实例，它用来执行一个任务，任务即一个实现了Runnable接口的类，一般来说，...
Java ScheduledExecutorService 使用学习
灵颖桥人的博客
04-03 1万+
Java 中的 ScheduledExecutorService 接口用来实现延迟执行或者定时执行的任务。在阅读 RocketMQ 源码(release-4.7.1版本)的过程中，发现很多地方都是使用的 ScheduledExecutorService 来实现定时任务。比如，在 broker 启动过程，BrokerController 类中使用 scheduledExecutorService 执行 broker 启动后的定时任务，比如消息消费偏移量 offset 的持久化定时任务，大致如下...
Task1 Python基础入门：变量与异常处理（第三天）
jshmxwc的博客
09-08 539
Task1 Python基础入门：变量与异常处理（第3天） 一般异常处理： try: 执行 except A as e: # 异常错误 执行 存在finally的异常： try: 执行 except： #条件执行 执行 … finally: #必须执行 执行 存在else的异常： try: 执行 except: 执行 else: #执行try的内容时，else执行，否则不执行 执行
血的教训！踩了定时线程池的坑，导致公司损失几千万
wdj_yyds的博客
07-12 211
DelayQueue是一个无界的，用于放置实现了Delayed接口的对象，只能在到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。我们看一下延时队列里对象的属性：java复制代码class MyDelayedTask implements Delayed{ // 当前任务创建时间 private long start = System.currentTimeMillis();// 延时时间 private long time;
ExecutorService学习
程序员的博客
03-28 485
转载：https://blog.csdn.net/fwt336/article/details/81530581 在我们的日常开发中，难免会使用到线程，部分还会用到多线程并发问题。我们知道，线程的创建和释放，需要占用不小的内存和资源。如果每次需要使用线程时，都new 一个Thread的话，难免会造成资源的浪费，而且可以无限制创建，之间相互竞争，会导致过多占用系统资源导致系统瘫痪。不利于扩展，比如...
线程池原理（六）：Executors
千磨万击还坚韧，任尔东西南北风
09-09 1165
Executors是线程池的工厂类，可以创建ExecutorService、ScheduledExecutorService、ThreadFactory、Callable的实例。
Java并发框架:Executor API详解
08-25
主要介绍了Java并发框架:Executor API详解，随着当今处理器中可用的核心数量的增加， 随着对实现更高吞吐量的需求的不断增长，多线程 API 变得非常流行。 Java 提供了自己的多线程框架，称为 Executor 框架,需要的...
xxl-job-executor:与xxl-job-executor的集成
04-19
xxl-job-executor的gin中间件背景xxl-job-executor-go是xxl-job的golang执行器，可以独立运行，有时候我们要与项目或者框架（如:gin框架）集成起来合并为一个服务，本项目因此而生。执行器项目地址与gin集成示例...
Java并发之线程池Executor框架的深入理解
08-26
主要介绍了Java并发之线程池Executor框架的深入理解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java 中Executor, ExecutorService 和 Executors 间的不同
08-30
主要介绍了java 中Executor, ExecutorService 和 Executors 间的不同的相关资料,需要的朋友可以参考下
ScheduledExecutorService
eafun_888的博客
03-12 175
来解决效率与定时任务的功能，主要作用是可以将定时任务与线程池功能结合使用 1：ScheduledExecutorService executor =Executors.newSingleThreadScheduledExecutor(); newSingleThreadScheduledExecutor() 在 JDK 的源码里 实例化 new ScheduledThreadPoolE...
并发编程与高并发（六）：线程调度-线程池
帅过驴的袋鼠的博客
10-19 703
介绍 所谓线程池，通俗的理解就是有一个池子，里面存放着已经创建好的线程，当有任务提交给线程池执行时，池子中的某个线程会主动执行该任务。如果池子中的线程数量不够应付数量众多的任务时，则需要自动扩充新的线程到池子中，但是该数量是有限的，就好比池塘的水界限一样。当任务比较少的时候，池子中的线程能够自动回收，释放资源。为了能够异步地提交任务和缓存未被处理的任务，需要有一个任务队列。 new Thread弊端 每次new Thread新建对象，性能较差 线程缺乏统一管理，可能无...
【多线程】创建线程池有几种方式
不想睡觉的橘子君的博客
07-20 507
经过源码的探究，可以看出，线程池的构造，可以使用newThreadPoolExecutor来直接构造一个自定义的线程池，或者Executors的方法来构造6种不同的线程池。Executors中的6种方法，其中有5种都是调用newThreadPoolExecutor来构造线程池，只有抢占式线程池WorkStealingPool是没有调用newThreadPoolExecutor来实现线程池。[1]，面试官线程池有哪几种创建方式，能详细的说下么？httpshttpshttpshttps。......
ThreadPoolExecutor中的submit()方法详细讲解
热门推荐
Widsom的博客
06-09 7万+
ThreadPoolExecutor中的submit()方法详细讲解在使用线程池的时候，发现除了execute()方法可以执行任务外，还发现有一个方法submit()可以执行任务。submit()有3个参数不一的方法，这些方法都是在ExecutorService接口中声明的，在AbstractExecutorService中实现，而ThreadPoolExecutor继承AbstractExecut
Java并发编程之调度线程池
隐风的博客
10-14 4279
调度线程池: 调度线程池是线程池类ThreadPoolExecutor的子类，复用了线程池的计算框架，主要用于解决任务在一定的时间间隔后重复执行的问题。 例子 public class ScheduledThreadPoolTest { /** * 以固定的频率调度，包括任务执行的时间 */ public static void scheduledAtFixRate(){ ScheduledExecutorService scheduledEx
ScheduledExecutorService详解
qq_41563912的博客
08-15 3万+
有线程池的特性，也可以实现任务循环执行，可以看作是一个简单地定时任务组件，因为有线程池特性，所以任务之间可以多线程并发执行，互不影响，当任务来的时候，才会真正创建线程去执行我们在做一些普通定时循环任务时可以用它，比如定时刷新字典常量，只需要不断重复执行即可，这篇文章讲解一下它的用法以及注意事项，不涉及底层原理。...
Java并发包线程池之Executors、ExecutorCompletionService工具类
weixin_30247781的博客
07-28 238
前言 前面介绍了Java并发包提供的三种线程池，它们用处各不相同，接下来介绍一些工具类，对这三种线程池的使用。 Executors Executors是JDK1.5就开始存在是一个线程池工具类，它定义了用于Executor、ExecutorService、ScheduledExecutorService、ThreadFactory和Callable的工厂和工具方法。在开始之前，先了...
ScheduledExecutorService 延迟 / 周期执行线程池
蚩尤后裔-汪茂雄
06-28 4万+
目录 Executor 结构图 ScheduleExecutorService 简述 对象创建方式 方法详解 schedule Runnable schedule Callable scheduleAtFixedRate scheduleWithFixedDelay 本文可参考《线程池理论 2》 Executor 结构图 ScheduleExecutorService...
ThreadPoolExecutor的中的submit和FutureTask || 通过Executors 创建线程池的一些实例（Callable和Runnable的在其中的体现）
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
02-22 3394
线程的创建方式，Callable接口和Future接口的配合，Runnable任务、Callable任务提交到线程池，他们之间的区别
ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
最新发布
12-23
`ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);` 这行代码创建了一个具有单个线程的定时任务执行器。 解析： - `ScheduledExecutorService` 是 Java 中的一个接口，它扩展了 `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值