03_java内置线程池(ScheduledExecutorService)

已于 2023-02-09 16:15:03 修改
阅读量388 收藏
点赞数
分类专栏： Java_线程池 文章标签： java 开发语言
于 2023-02-09 15:31:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w7635122886/article/details/128953736
版权

1，ScheduledExecutorServic介绍

ScheduledExecutorService是ExecutorService的子接口,具备了延迟运行或定期执行任务的能力,

2，常用获取方式如下

  • static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
    创建一个可重用固定线程数的线程池且允许延迟运行或定期执行任务;
  • static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
    创建一个可重用固定线程数的线程池且线程池中的所有线程都使用ThreadFactory来创建,且允许延迟运行或定期执行任务;
  • static ScheduledExecutorService newSingleThreadScheduledExecutor()
    创建一个单线程执行程序，它允许在给定延迟后运行命令或者定期地执行。
  • static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)
    创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期地执行。

3，常用方法如下

  • ScheduledFuture schedule(Callable callable, long delay, TimeUnit unit)
    延迟时间单位是unit,数量是delay的时间后执行callable。
  • ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
    延迟时间单位是unit,数量是delay的时间后执行command。
  • ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
    延迟时间单位是unit,数量是initialDelay的时间后,每间隔period时间重复执行一次command。
  • ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
    创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

4，延迟执行

4.1，newScheduledThreadPool(int corePoolSize)

延迟执行

package com.study.javaThreadPool.demo02_scheduledExecutorServic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class Demo01_NewScheduledThreadPool_Int {
    public static void main(String[] args) {
        //1，获取一个延迟执行线程池任务的对象
        ScheduledExecutorService es = Executors.newScheduledThreadPool(3);

        //创建多个任务对象,提交任务，每个任务延迟5秒执行
        es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
        log.info("ScheduledExecutorService执行结束");
        es.shutdown();
    }
}

@Slf4j
class MyRunnable1 implements Runnable{
    private int id;

    public MyRunnable1(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称
        String name = Thread.currentThread().getName();
        log.info(name +"执行了任务,编号为:"+id);
    }
}

在这里插入图片描述
在这里插入图片描述

4.2，newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

参与线程的创建

package com.study.javaThreadPool.demo02_scheduledExecutorServic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

@Slf4j
public class Demo02_NewScheduledThreadPool_Int_ThreadFactory {
    public static void main(String[] args) {
        //1，获取一个延迟执行线程池任务的对象
        ScheduledExecutorService es = Executors.newScheduledThreadPool(3, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r,"线程名称111");
            }
        });

        //创建多个任务对象,提交任务，每个任务延迟5秒执行
        es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
        log.info("ScheduledExecutorService执行结束");
        es.shutdown();
    }
}

@Slf4j
class MyRunnable2 implements Runnable{
    private int id;

    public MyRunnable2(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称
        String name = Thread.currentThread().getName();
        log.info(name +"执行了任务,编号为:"+id);
    }
}

在这里插入图片描述

4.3，newSingleThreadScheduledExecutor()

只创建一个线程

package com.study.javaThreadPool.demo02_scheduledExecutorServic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

@Slf4j
public class Demo03_NewSingleThreadScheduledExecutor {
    public static void main(String[] args) {
        //1，获取一个延迟执行线程池任务的对象
        ScheduledExecutorService es = Executors.newSingleThreadScheduledExecutor();

        //创建多个任务对象,提交任务，每个任务延迟5秒执行
        es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
        log.info("ScheduledExecutorService执行结束");
        es.shutdown();
    }
}

@Slf4j
class MyRunnable3 implements Runnable{
    private int id;

    public MyRunnable3(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称
        String name = Thread.currentThread().getName();
        log.info(name +"执行了任务,编号为:"+id);
    }
}

在这里插入图片描述

4.4，newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

package com.study.javaThreadPool.demo02_scheduledExecutorServic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

@Slf4j
public class Demo04_NewSingleThreadScheduledExecutor_ThreadFactory {
    public static void main(String[] args) {
        //1，获取一个延迟执行线程池任务的对象
        ScheduledExecutorService es = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r,"线程名称222");
            }
        });

        //创建多个任务对象,提交任务，每个任务延迟5秒执行
        es.schedule(new MyRunnable1(1),5, TimeUnit.SECONDS);
        log.info("ScheduledExecutorService执行结束");
        es.shutdown();
    }
}

@Slf4j
class MyRunnable4 implements Runnable{
    private int id;

    public MyRunnable4(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称
        String name = Thread.currentThread().getName();
        log.info(name +"执行了任务,编号为:"+id);
    }
}

在这里插入图片描述

5，重复执行

5.1 scheduleAtFixedRate

scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

延迟时间单位是unit,数量是initialDelay的时间后,每间隔period时间重复执行一次command。

package com.study.javaThreadPool.demo02_scheduledExecutorServic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class Demo05_ScheduleAtFixedRate {
    public static void main(String[] args) {
        //1，获取一个延迟执行线程池任务的对象
        ScheduledExecutorService es = Executors.newScheduledThreadPool(1);

        //创建多个任务对象,提交任务，每个任务延迟5秒执行
        MyRunnable5 runnble = new MyRunnable5(1);
        /**
         * 参数数目
         *  1：运行任务
         *  2：初始等待时间
         *  3：间隔时间
         *  4：时间单位
         *
         *  运行1秒后每个5秒重复执行
         */
        es.scheduleAtFixedRate(runnble,1,5, TimeUnit.SECONDS);
        log.info("ScheduledExecutorService执行结束");
    }
}

@Slf4j
class MyRunnable5 implements Runnable{
    private int id;

    public MyRunnable5(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称
        String name = Thread.currentThread().getName();

        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.info(name +"执行了任务,编号为:"+id);
    }
}

在这里插入图片描述

5.2 scheduleWithFixedDelay

scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

package com.study.javaThreadPool.demo02_scheduledExecutorServic;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Slf4j
public class Demo06_ScheduleWithFixedDelay {
    public static void main(String[] args) {
        //1，获取一个延迟执行线程池任务的对象
        ScheduledExecutorService es = Executors.newScheduledThreadPool(1);

        //创建多个任务对象,提交任务，每个任务延迟5秒执行
        MyRunnable6 runnble = new MyRunnable6(1);
        /**
         * 参数数目
         *  1：运行任务
         *  2：初始等待时间
         *  3：间隔时间
         *  4：时间单位
         *
         *  运行1秒后每个5秒重复执行
         */
        es.scheduleWithFixedDelay(runnble,1,5, TimeUnit.SECONDS);
        log.info("ScheduledExecutorService执行结束");
    }
}

@Slf4j
class MyRunnable6 implements Runnable{
    private int id;

    public MyRunnable6(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称
        String name = Thread.currentThread().getName();
        log.info(name +"执行了任务,编号为:"+id);
    }
}

在这里插入图片描述

李乃龙1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Thread的setDaemon(true)方法的作用
02-09 5万+
定义：守护线程--也称“服务线程”，在没有用户线程可服务时会自动离开。优先级：守护线程的优先级比较低，用于为系统中的其它对象和线程提供服务。 设置：通过setDaemon(true)来设置线程为“守护线程”；将一个用户线程设置为守护线程的方式是在 线程对象创建 之前 用线程对象的setDaemon方法。 example: 垃圾回收线程就是一个经典的守护线程，当我们的程序中不再有任何运行的Thr
ScheduledExecutorService定时周期执行指定的任务
热门推荐
不积跬步无以至千里，不积小流无以成江海。
01-08 20万+
一：简单说明 ScheduleExecutorService接口中有四个重要的方法，其中scheduleAtFixedRate和scheduleWithFixedDelay在实现定时程序时比较方便。 下面是该接口的原型定义 java.util.concurrent.ScheduleExecutorService extendsExecutorService extendsExecut
Java并发——ScheduledExecutorService
吴声子夜歌的博客
06-24 2769
ScheduledExecutorService 类 Scheduledexecutor Service的主要作用就是可以将定时任务与线程池功能结合使用。 ScheduledThreadPoolExecutor使用Callable延迟运行 public class MyCallableAA implements Callable<String> { @Override public String call() throws Exception { try {
ScheduledExecutorService详解
最新发布
Mr朱鹏的博客
05-14 963
ScheduledExecutorService详解
Java ScheduledExecutorService
haoranhaoshi的博客
11-10 209
delay时长后执行一次任务。TimeUnit是时间单位枚举。 public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit); delay时长后执行一次有返回值的任务。 public <V> ScheduledFuture<V> schedule(Callable<V
并发编程(九)-ScheduledExecutorService源码分析
流星1688
03-28 1276
ScheduledExecutorService 是 Java 并发包中提供的一个接口，继承ExecutorService接口，是Executor框架的一个扩展。它可以用于调度任务在指定的时间或周期性地执行。相比于 Timer 和 TimerTask，ScheduledExecutorService 提供了更加灵活的任务调度机制，可以控制任务的取消、延迟、周期等，同时也支持并发执行多个任务。
jspmusicupload_java_streamzdd_
09-30
在Java Web应用中，文件上传通常使用`Commons FileUpload`库或Java Servlet 3.0及以上版本的内置API来处理。用户选择音乐文件后，这些文件会被转换为`Part`对象，然后通过`HttpServletRequest`的`getParts()`方法...
Java:通用 Java 存储库
07-02
6. **多线程**：Java内置了对多线程的支持，通过Thread类和Runnable接口实现。线程池API如ExecutorService、ThreadPoolExecutor和ScheduledExecutorService提供了更高级的线程管理。 7. **异常处理**：Java强制使用...
Java调度原理及使用.docx
05-09
除了内置的调度器，Java社区还发展出了一些强大的第三方库，如Quartz和JCronTab。Quartz是一个功能全面的作业调度框架，支持复杂的调度规则，如表达式、作业集群和持久化等。而JCronTab则提供了一个轻量级的解决方案...
throttler:Java 节流器演示
07-05
在Java中，这通常通过使用定时器、线程池或者其他并发控制机制来实现。节流有助于维持系统的稳定性和性能，尤其是在高并发或大数据量的环境下。 2. **Java中的节流实现** Java并没有内置的节流库，但可以通过以下...
Java基于pushDeer实现定时提醒.zip
12-14
在Java中，实现定时任务通常有多种方式，例如使用Java内置的`java.util.Timer`和`TimerTask`类，或者是使用`java.concurrent.ScheduledExecutorService`。然而，`ScheduledExecutorService`更为现代，且更推荐，因为...
ScheduledExecutorService 使用及注意事项
xixisi888的博客
09-15 8926
还在手写循环线程？就用他（ScheduledExecutorService），优雅点！ 优点： 最大优点除了线程池的特性以外，可以实现循环或延迟任务。 下面部分内容引用该博客：ScheduledExecutorService的使用 引用博客内容 ScheduledExecutorService 和 Timer 的区别 Timer的内部只有一个线程，如果有多个任务的话就会顺序执行，这样我们的延迟时间和循环时间就会出现问题。 ScheduledExecutorService是线程池，所以就不会出现
java线程池
u_will_c的博客
09-18 890
为什么用使用线程池 1.降低资源消耗：很多线程执行的时间很短，如果每次需要执行线程都去创建和销毁线程，会产生很多不必要的开销。 2.提高线程的可管理性 Executors类 大致结构：在Executors类中，定义了几个静态内部类，如： DelegatedExecutorService FinalizableDelegatedExecutorService DelegatedSched...
java内置线程池ExecutorService、ScheduledExecutorService 接口、Executors工具类、ScheduledThreadPoolExecutor
记录点滴
09-04 867
构造方法 七个参数： 构造方法： int corePoolSize ->核心线程数量（允许刚开始创建线程的数量） int maximumPoolSize ->最大线程数量 long keepAliveTime ->最大空闲时间 TimeUnit unit ->时间单位 BlockingQueue<Runnable> workQueue ->任务列队（临时缓冲区） ThreadFactory threadFactory ->线程工厂，是一个接
Java四种线程池 newCachedThreadPool ,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor
03-24 4175
Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor 1、new Thread的弊端 1 2 3 4 5 6 7 newThread(newRunnable() { @O...
深入学习Java中的线程池
摸鱼胖嘟嘟的博客
04-10 933
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。创建自定义线程池，参数可自定义配置。：线程池的基本大小，即在没有任务需要执行的时候线程池的大小，并且只有在工作队列满了的情况下才会创建超出这个数量的线程。
线程池用法详解
.
04-04 1291
线程池用法详解 前言 为什么需要用到线程池？ 众所周知线程是操作系统一种宝贵的资源，创建和销毁都很耗费资源，对此，java中针对这种情况实现出线程池思想，维护一定数量的线程，用到时候就不需要去创建，不使用时候，就销毁一定量的，保留一部分线程数量。 Java线程池的工作流程 Java线程池的工作流程为：线程池刚被创建时，只是向系统申请一个用于执行线程队列和管理线程池的线程资源。在调用execute()添加一个任务时，线程池会按照以下流程执行任务。 如果正在运行的线程数量少于corePoolSize（用户定
ScheduledExecutorService 根据条件终止调度任务
netboy
03-20 3万+
package com.taobao.vcloud.scheduler.job; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.Schedule
ScheduledExecutorService线程池
08-24
ScheduledExecutorService是Java中用来执行定时任务的线程池。它是Executor框架的一种实现，可以在指定的延迟之后或者按固定的时间间隔周期性地执行任务。 使用ScheduledExecutorService可以方便地创建一个线程池，其中的线程会自动调度执行任务，而不需要手动创建和管理线程。ScheduledExecutorService中的线程池可以根据需要动态地调整线程的数量，提供了更好的灵活性和效率。 使用ScheduledExecutorService来创建一个线程池可以通过Executors类的静态方法newScheduledThreadPool()来实现，例如： ```java ScheduledExecutorService executor = Executors.newScheduledThreadPool(5); ``` 上述代码创建了一个包含5个线程的ScheduledExecutorService线程池。 然后，可以使用ScheduledExecutorService的schedule()方法来安排任务的执行。schedule()方法有多个重载形式，其中最常用的形式接受一个Runnable对象和一个延迟时间作为参数，例如： ```java executor.schedule(new RunnableTask(), 5, TimeUnit.SECONDS); ``` 上述代码将会在5秒之后执行RunnableTask任务。 除了schedule()方法外，还有scheduleAtFixedRate()和scheduleWithFixedDelay()方法可以用来周期性地执行任务。scheduleAtFixedRate()方法可以在固定的时间间隔内周期性地执行任务，而scheduleWithFixedDelay()方法则是在任务执行完成后在固定的延迟时间后再次执行任务。 总结起来，ScheduledExecutorService线程池提供了一种方便的方式来执行定时任务，可以根据需要动态调整线程数量，更加灵活和高效。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值