周期性线程池 newScheduledThreadPool

已于 2024-04-05 21:51:37 修改
阅读量2.1k 收藏 6
点赞数
分类专栏： 基础知识 文章标签： java 开发语言
于 2023-05-21 13:31:24 首次发布
好好学习天天向上
本文链接：https://blog.csdn.net/weixin_37646636/article/details/130780284
版权

[Q&A] newScheduledThreadPool定义

ScheduledThreadPoolExecutor主要用来延迟运行任务，或者定期执行任务。
ScheduledThreadPoolExecutor的功能与Timer类似。Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以对应多个后台线程数。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
    
public ScheduledThreadPoolExecutor(int corePoolSize) {
    ThreadPoolExecutor (corePoolSize, 
	    			    Integer.MAX_VALUE,     // DelayQueue是一个无界队列，所以设置maximumPoolSize的大小没有什么效果
	     				10, TimeUnit.MILLI_SCALE, 
	     				new DelayedWorkQueue());
}

[Q&A] ScheduledFutureTask主要包含3个成员变量 

long型成员变量time，          表示这个任务将要被执行的具体时间。
long型成员变量sequenceNumber，表示这个任务被添加到ScheduledThreadPoolExecutor中的序号。
long型成员变量period，        表示任务执行的间隔周期。

[Q&A] DelayedWorkQueue排序规则 

# 也就是说，执行时间短的在前面，如果两个任务的执行时间相同，那么先提交的任务将被先执行

ScheduledFutureTask的 time 小的排在前面（时间早的任务将被先执行）。
如果两个ScheduledFutureTask的 time 相同，sequenceNumber小的排在前面

[Q&A] ScheduledThreadPoolExecutor常用方法 

schedule()                 延时 执行

scheduleWithFixedDelay()   以固定的 延时 执行
延时（delay）：指的是一次执行终止和下一次执行开始之间的间隔。

scheduleAtFixedRate()	   以固定的 周期 执行
周期（period）：指的是两次成功执行之间的时间。
上一个任务开始计时，一个周期后检测上一个任务是否执行完毕，如果上一个任务执行完毕，则当前任务立即执行，如果上一个任务没有执行完毕，则需要等上一个任务执行完毕后立即执行。

[Q&A] ScheduledThreadPoolExecutor的执行

ScheduledThreadPoolExecutor的执行主要分为两大部分。
1）当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate()方法或者scheduleWithFixedDelay()方法时，会向ScheduledThreadPoolExecutor的DelayQueue添加一个实现了RunnableScheduledFutur接口的ScheduledFutureTask。
2）线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。

[Q&A] 把ScheduledFutureTask放入DelayQueue中的过程 

# 添加任务分为3大步骤。
# 1）获取Lock。

# 2）添加任务。
·向PriorityQueue添加任务。
·如果在上面2.1中添加的任务是PriorityQueue的头元素，唤醒在Condition中等待的所有线程。

# 3）释放Lock。

在这里插入图片描述

[Q&A] 获取ScheduledFutureTask任务的过程 

# 获取任务分为3大步骤
# 1）获取Lock。

# 2）获取周期任务。
·如果PriorityQueue为空，当前线程到Condition中等待；否则执行下面的2.2。
·如果PriorityQueue的头元素的time时间比当前时间大，到Condition中等待到time时间；否则执行下面的2.3。
·获取PriorityQueue的头元素（2.3.1）；如果PriorityQueue不为空，则唤醒在Condition中等待的所有线程（2.3.2）。
# ScheduledThreadPoolExecutor在一个循环中执行步骤2，直到线程从PriorityQueue获取到一个元素之后（执行2.3.1之后），才会退出无限循环（结束步骤2）。

# 3）释放Lock。

在这里插入图片描述

[Q&A] ScheduledThreadPoolExecutor中的线程1执行某个周期任务的4个步骤 

1）线程1从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前时间。
2）线程1执行这个ScheduledFutureTask。
3）线程1修改ScheduledFutureTask的time变量为下次将要被执行的时间。
4）线程1把这个修改time之后的ScheduledFutureTask放回DelayQueue中（Delay-Queue.add()）。

在这里插入图片描述

-----------------------------------------------------------------------------读书笔记摘自 书名：Java并发编程的艺术 作者：方腾飞；魏鹏；程晓明

常见用途

参考：Executor框架的成员

线程任务

public class Task implements Runnable {
    private final String name;

    public Task(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " → " + name + " Start Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " → " + name + " End   Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1. 延迟10秒执行，schedule(new Task(), 10, TimeUnit.SECONDS)

public class ScheduledThreadPool {
    public static void main(String args[]) throws InterruptedException, ExecutionException {

        System.out.println(Thread.currentThread().getName() + "线程: Start at: " + new Date());

        ScheduledThreadPoolExecutor exec = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(5);

        for (int i = 0; i < 10; i++) {
            System.out.println("添加了第" + i + "个线程任务 " + new Date());
            exec.schedule(new Task("线程名字" + i), 10, TimeUnit.SECONDS);// 延迟10秒执行
        }

        exec.shutdown();

        System.out.println(Thread.currentThread().getName() + "线程: 打卡" + new Date());

        while (!exec.isTerminated()) {
            // wait for all tasks to finish
        }

        System.out.println(Thread.currentThread().getName() + "线程: Finished all threads at：" + new Date());
    }
}
执行结果
main线程: Start at: Sat May 20 12:51:32 CST 2023
添加了第0个线程任务 Sat May 20 12:51:32 CST 2023
添加了第1个线程任务 Sat May 20 12:51:32 CST 2023
添加了第2个线程任务 Sat May 20 12:51:32 CST 2023
添加了第3个线程任务 Sat May 20 12:51:32 CST 2023
添加了第4个线程任务 Sat May 20 12:51:32 CST 2023
添加了第5个线程任务 Sat May 20 12:51:32 CST 2023
添加了第6个线程任务 Sat May 20 12:51:32 CST 2023
添加了第7个线程任务 Sat May 20 12:51:32 CST 2023
添加了第8个线程任务 Sat May 20 12:51:32 CST 2023
添加了第9个线程任务 Sat May 20 12:51:32 CST 2023
main线程: 打卡Sat May 20 12:51:32 CST 2023
pool-1-thread-5 → 线程名字2 Start Time = Sat May 20 12:51:42 CST 2023
pool-1-thread-3 → 线程名字1 Start Time = Sat May 20 12:51:42 CST 2023
pool-1-thread-4 → 线程名字3 Start Time = Sat May 20 12:51:42 CST 2023
pool-1-thread-2 → 线程名字4 Start Time = Sat May 20 12:51:42 CST 2023
pool-1-thread-1 → 线程名字0 Start Time = Sat May 20 12:51:42 CST 2023
pool-1-thread-3 → 线程名字1 End Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-5 → 线程名字2 End Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-3 → 线程名字5 Start Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-5 → 线程名字6 Start Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-4 → 线程名字3 End Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-4 → 线程名字7 Start Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-2 → 线程名字4 End Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-2 → 线程名字8 Start Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-1 → 线程名字0 End Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-1 → 线程名字9 Start Time = Sat May 20 12:51:45 CST 2023
pool-1-thread-3 → 线程名字5 End Time = Sat May 20 12:51:48 CST 2023
pool-1-thread-5 → 线程名字6 End Time = Sat May 20 12:51:48 CST 2023
pool-1-thread-4 → 线程名字7 End Time = Sat May 20 12:51:48 CST 2023
pool-1-thread-2 → 线程名字8 End Time = Sat May 20 12:51:48 CST 2023
pool-1-thread-1 → 线程名字9 End Time = Sat May 20 12:51:48 CST 2023
main线程: Finished all threads at：Sat May 20 12:51:48 CST 2023
从控制台结果可以看出：
5个线程去执行10个线程任务，线程任务放到线程池后延迟10秒执行

2. 延迟1秒，间隔4秒再执行，scheduleWithFixedDelay(new Task(), 2, 4, TimeUnit.SECONDS)

public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,    // the task to execute
                                                 long initialDelay,   // the time to delay first execution
                                                 long delay,          // the delay between the termination of one execution and the commencement of the next
                                                 TimeUnit unit);      // the time unit of the initialDelay and delay parameters

public class FixedDelay {
    public static void main(String args[]) throws InterruptedException, ExecutionException {
        way1();
        way2();
    }

    private static void way2() {
        System.out.println(Thread.currentThread().getName() + "线程: Start at: " + new Date());

        ScheduledThreadPoolExecutor scheduledExecutorService = new ScheduledThreadPoolExecutor(1);

        scheduledExecutorService.scheduleWithFixedDelay(() -> {
            System.out.println(Thread.currentThread().getName() + " → " + " Start Time = " + new Date());
            try {
                sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName() + " → " + " End   Time = " + new Date());
        }, 1, 4, TimeUnit.SECONDS);  // 延迟 1s，周期 4s
    }

    private static void way1() {
        System.out.println(Thread.currentThread().getName() + "线程: Start at: " + new Date());

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);

        scheduledExecutorService.scheduleWithFixedDelay(new Task("任务"), 1, 4, TimeUnit.SECONDS);  // 延迟 1s, 周期 4s
    }
}
执行结果分析
main线程: Start at: Sat May 20 18:54:29 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 18:54:30 CST 2023延迟 1 s
pool-1-thread-1 → 任务 End Time = Sat May 20 18:54:33 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 18:54:37 CST 2023等待 4 s 再开始
pool-1-thread-1 → 任务 End Time = Sat May 20 18:54:40 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 18:54:44 CST 2023等待 4 s 再开始
pool-1-thread-1 → 任务 End Time = Sat May 20 18:54:47 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 18:54:51 CST 2023等待 4 s 再开始
pool-1-thread-1 → 任务 End Time = Sat May 20 18:54:54 CST 2023

3. 延时1秒， 周期4秒，scheduleAtFixedRate(new Task(), 1, 4, TimeUnit.SECONDS)

执行结果分析
前置条件任务用时 3 秒， period = 4 秒
main线程: Starting at: Sat May 20 19:31:13 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:31:14 CST 2023延时 1 秒
pool-1-thread-1 → 任务 End Time = Sat May 20 19:31:17 CST 2023任务用时 3 秒
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:31:18 CST 2023period（周期） 4 秒
pool-1-thread-1 → 任务 End Time = Sat May 20 19:31:21 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:31:22 CST 2023
pool-1-thread-1 → 任务 End Time = Sat May 20 19:31:25 CST 2023
任务用时 < period（周期） ，等待时长为：period需要等待period再开始下一个
前置条件任务用时 3 秒， period = 3 秒
main线程: Starting at: Sat May 20 19:35:33 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:35:34 CST 2023
pool-1-thread-1 → 任务 End Time = Sat May 20 19:35:37 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:35:37 CST 2023period（周期） 3 秒
pool-1-thread-1 → 任务 End Time = Sat May 20 19:35:40 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:35:40 CST 2023
pool-1-thread-1 → 任务 End Time = Sat May 20 19:35:43 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:35:43 CST 2023
任务用时 = period（周期） ，等待时长为：period需要等待period再开始下一个
前置条件任务用时 3 秒， period = 2 秒
main线程: Starting at: Sat May 20 19:37:03 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:37:04 CST 2023
pool-1-thread-1 → 任务 End Time = Sat May 20 19:37:07 CST 2023
pool-1-thread-1 → 任务 Start Time = Sat May 20 19:37:07 CST 2023period（周期） 2 秒 无效，以任务用时为准，故结束就开始
pool-1-thread-1 → 任务 End Time = Sat May 20 19:37:10 CST 2023
任务用时 > period（周期） 4 秒 ，等待时长为：任务用时等任务结束后直接开始执行下一个

定时任务☞每天晚上9点执行一次

public class FixedRateDemo {
    public static void main(String args[]) throws InterruptedException, ExecutionException, ParseException {
        System.out.println(Thread.currentThread().getName() + "线程: Starting at: " + new Date());

        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        // long oneDay = 24 * 60 * 60 * 1000=86400000; // 1天24小时作为周期
        // long initDelay = getTimeMillis("21:00:00") - System.currentTimeMillis(); // 当前时间

        long oneDayPeriod = 10000; // 正常1天=24*60*60*1000=86400000ms,这里用5s来模拟
//        long initDelay = getTimeMillis("21:00:00") - getTimeMillis("20:59:57"); // 假设模拟此时当天的20:59:57 → 3000ms
        long initDelay = getTimeMillis("21:00:00") - getTimeMillis("21:00:03"); // 假设模拟此时当天的21:00:03 →-3000ms

        initDelay = initDelay > 0 ? initDelay : oneDayPeriod + initDelay;

        executor.scheduleAtFixedRate(new Task("定时任务"), initDelay, oneDayPeriod, TimeUnit.MILLISECONDS);
    }


    /**
     * 获取指定时间对应的毫秒数
     */
    private static long getTimeMillis(String time) throws ParseException {
        DateFormat dateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        DateFormat dayFormat = new SimpleDateFormat("yy-MM-dd");
        Date curDate = dateFormat.parse(dayFormat.format(new Date()) + " " + time);
        return curDate.getTime();
    }
}
执行结果模拟数据分析
前置条件：模拟20:59:57开始执行定时任务，21:00:00正式执行，周期10秒
main线程: Starting at: Sat May 20 20:27:54 CST 202320:59:57开始执行时间
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:27:57 CST 202321:00:00当天到9点开始执行
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:28:00 CST 202321:00:03任务执行完毕
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:28:07 CST 202321:00:00第2天9点重新执行
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:28:10 CST 2023
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:28:17 CST 2023
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:28:20 CST 2023
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:28:27 CST 2023
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:28:30 CST 2023
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:28:37 CST 2023
前置条件：模拟21:00:03开始执行定时任务，21:00:00正式执行，周期10秒
main线程: Starting at: Sat May 20 20:41:50 CST 202321:00:03开始执行时间
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:41:57 CST 202321:00:00第2天9点开始执行
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:42:00 CST 202321:00:03任务执行完毕
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:42:07 CST 202321:00:00第3天9点重新执行
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:42:10 CST 2023
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:42:17 CST 2023
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:42:20 CST 2023
pool-1-thread-1 → 定时任务 Start Time = Sat May 20 20:42:27 CST 2023
pool-1-thread-1 → 定时任务 End Time = Sat May 20 20:42:30 CST 2023
张紫娃
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程池之newScheduledThreadPool
qq_40308101的博客
03-26 6458
1、特点： 延时启动 、定时启动 、可以自定义最大线程池数量 2、创建实例： ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3); 这里如果没有特殊需求要指定最大线程池数量的话，建议最大线程池数量=运行程序机器的cpu核心数，即 int cpuNubmer = Run...
ScheduledThreadPoolExecutor(定时任务线程池)简单理解
qq_37803406的博客
02-24 3868
本文主要介绍了可定时线程池的核心原理，从宏观角度大概分析了线程池工作方式，如有不足，请指出，谢谢。 1.什么是线程池 线程池顾名思义是一个线程缓存的‘池子’。线程是稀缺资源，线程如果创建的太多，会消耗系统的资源，还会降低系统的稳定性，所以java中通过线程池来统一管理分配线程这个稀缺的资源，达到资源重复利用。 2.线程池的出现 在web系统中，服务器需要接受大量的并发请求，一个请求就会对应一个...
newScheduledThreadPool创建线程池学习
努力改变人生
09-16 606
schedule方法（首次执行延迟delay秒执行） package com.glch.threads; import java.text.SimpleDateFormat; import java.util.Date; import java.util.concurrent.Callable; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledFuture; impo.
ScheduledThreadPoolExecutor 周期性执行任务的线程池作用，基本使用，使用场景
最新发布
weixin_44131922的博客
05-23 495
是Java并发编程中一个非常实用的类，它是包下的一个线程池实现，专为定时或周期性任务执行而设计。它提供了灵活且强大的定时任务调度功能，相比传统的Timer类，它具备更好的并发控制能力和错误处理机制。
java线程池（四）之newScheduledThreadPool
weixin_44613100的博客
06-07 1118
newScheduledThreadPool测试类 package com.thread.pool; import java.util.Date; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public class TestScheduledPool { public stat
并发编程 定时线程池ScheduledThreadPoolExecutor学习总结
weixin_45161367的博客
07-23 609
并发编程 定时线程池ScheduledThreadPoolExecutor学习总结
java中四种线程池及poolSize、corePoolSize、maximumPoolSize
公众号：BennuCTech
01-04 4万+
Executors提供四种线程池： newCachedThreadPool ：缓存线程池，如果线程池长度超过处理需要，可回收空闲线程，若无可回收，则新建线程。newFixedThreadPool ： 定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。newScheduledThreadPool ： 计划线程池，支持定时及周期性任务执行。newSingleThreadExecutor...
四种Java线程池用法解析
09-02
这是一个定长线程池，不仅支持定时执行，还支持周期性执行任务。可以用来安排在给定延迟后执行一次任务，或者周期性地执行任务。这对于需要定期维护或者清理的任务非常有用。例如，可以使用`scheduleAtFixedRate`或...
深入理解Java 线程池
08-18
此线程池支持定时以及周期性执行任务的需求。 在实际开发中，线程池可以帮助开发者更好地管理和控制线程的执行，提高系统的性能和效率。但是，需要注意的是，线程池的配置需要根据实际情况进行调整，否则可能会导致...
android线程池
01-19
适用于需要周期性任务或者延时任务的场景，比如心跳检测、定时任务执行等。 六、自定义线程池 除了预定义的线程池，开发者还可以根据实际需求自定义线程池。通过ThreadPoolExecutor构造函数，我们可以设置核心线程...
java 四种线程池实例
06-06
4. **ScheduledThreadPool**: `Executors.newScheduledThreadPool(int corePoolSize)`创建一个支持定时及周期性任务执行的线程池。它可以安排任务在未来某个时间点执行，或者周期性地重复执行。这对于需要定时任务的...
java 线程池的实现方法
08-25
4. **newSingleThreadScheduledExecutor()** 和 **newScheduledThreadPool(int corePoolSize)**：这两者都用于定时或周期性地执行任务，但前者只有一个工作线程，后者可以有多个。它们都继承自`...
ScheduledThreadPoolExecutor 及 ThreadPoolExecutor的基本使用及说明
fumeidonga的博客
07-29 1851
ScheduledThreadPoolExecutor 及 ThreadPoolExecutor
周期性任务执行实现模板线程类
海风鸥 - 编程技术交流
11-29 1294
周期性任务执行实现模板线程类，是满足在开发过程中需要定时并周期性去执行相同任务的控制。 1.为什么要写这个线程类？ 这其实跟我着手的工作主要是控制仪器的动作执行和状态返回，需要定时周期性执行相行的任务或查询仪器的各类状态。 2. 如何保证一个任务周期性并稳定的执行对仪器的多线程控制很重要，下面以的封装好的周期性任务执行线程类代码来作说明。 namespace { pub...
newScheduledThreadPool创建可间隔时间执行的线程池
MiniCTO
10-20 3846
newScheduledThreadPool，创建一个可间隔时间执行的线程池，并且可以指定数量，以前确实没这么写过，都是写while循环，看来后面我要恶补一下线程池的技术了，下面是我抽出来的部分代码。 package ess.tester;import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecu
线程池的状态切换
liuhehe的博客
04-20 525
import java.util.concurrent.Callable; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; impor.
理解ThreadPoolExecutor源码(一)线程池的corePoolSize、maximumPoolSize和poolSize
热门推荐
aty
09-13 5万+
我们知道，受限于硬件、内存和性能，我们不可能无限制的创建任意数量的线程，因为每一台机器允许的最大线程是一个有界值。也就是说ThreadPoolExecutor管理的线程数量是有界的。线程池就是用这些有限个数的线程，去执行提交的任务。然而对于多用户、高并发的应用来说，提交的任务数量非常巨大，一定会比允许的最大线程数多很多。为了解决这个问题，必须要引入排队机制，或者是在内存中，或者是在硬盘等容量很大的
ScheduledThreadPoolExecutor详解实战
weixin_43942106的博客
01-06 4644
ScheduledThreadPoolExecutor详解 简介 继承自ThreadPooExecutor,为任务提供延迟或周期执行. 使用专门的ScheduledFutureTask来执行周期任务,也可以接收不需要时间调度的任务. 使用DelayedWorkQueue存储任务.(一种无界延迟队列) 支持线程池关闭后可执行,可选择线程池关闭后支持继续执行周期或延迟任务. 解析 内部有两个内部类: ScheduledFutureTask:可以延迟执行的异步运算任务. DelayedWorkQueue:存
newScheduledThreadPool
06-11
`newScheduledThreadPool` 是 Java 中的一个线程池。它创建一个固定大小的线程池，用于执行定时任务和周期性任务。该线程池可以按照指定的时间间隔执行任务，也可以按照指定的时间点执行任务。与其他类型的线程池不同，该线程池中的线程数量是固定的，因此不会因为创建太多线程而导致系统负荷过大。该线程池适合于需要定期执行任务的场景，如定时备份、定时清理等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值