ScheduledThreadPoolExecutor-并发编程(Java)

最新推荐文章于 2024-07-05 07:45:00 发布
最新推荐文章于 2024-07-05 07:45:00 发布
阅读量593 收藏
点赞数
分类专栏： # 并发编程 文章标签： java ScheduledThread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaogzhen/article/details/121968688
版权
本文对比了Java中Timer和ScheduledThreadPoolExecutor实现定时任务的优缺点，展示了它们在延迟执行和异常处理上的不同。Timer任务串行执行，异常会中断后续任务；而ScheduledThreadPoolExecutor支持并发执行，异常不会阻塞任务，但需额外处理。同时，文章给出了定时任务应用的示例，演示了如何实现每周四4:00:00执行的任务。
摘要由CSDN通过智能技术生成

1、Timer

在认为调度线程池功能加入之前，可以使用java.util.Timer来实现定时功能。

  • 优点：简单易用

  • 缺点：由于所以认为都由同一个线程调度，因此所有任务都是串行执行

    • 前一个认为的延迟或者异常将会影响到之后的任务

  • 延迟示例：

    import lombok.extern.slf4j.Slf4j;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

@Slf4j(topic = "c.TestTimer01")
public class TestTimer01 {
    public static void main(String[] args) {
        Timer timer = new Timer();

        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                log.debug("task 1...");
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                log.debug("task 2...");
            }
        };

        timer.schedule(task1, 1000);
        timer.schedule(task2, 1000);
    }
}
// 输出
2021-12-16 09:04:57.752 DEBUG [main] c.TestTimer01 - start...
2021-12-16 09:04:58.769 DEBUG [Timer-0] c.TestTimer01 - task 1...
2021-12-16 09:05:00.776 DEBUG [Timer-0] c.TestTimer01 - task 2...
    • 任务2并没有如预期的延迟1s后开始执行，而是等待任务1执行完毕在执行

  • 异常示例

    import lombok.extern.slf4j.Slf4j;

import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.TimeUnit;

@Slf4j(topic = "c.TestTimer02")
public class TestTimer02 {
    public static void main(String[] args) {
        Timer timer = new Timer();

        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                log.debug("task 1...");
                int i = 1 / 0;
            }
        };

        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                log.debug("task 2...");
            }
        };
        log.debug("start...");
        timer.schedule(task1, 1000);
        timer.schedule(task2, 1000);
    }
}

// 输出
2021-12-16 09:07:13.722 DEBUG [main] c.TestTimer02 - start...
2021-12-16 09:07:14.727 DEBUG [Timer-0] c.TestTimer02 - task 1...
Exception in thread "Timer-0" java.lang.ArithmeticException: / by zero
    • 任务1异常，程序中断，并没有执行任务2

2、ScheduledThreadPoolExecutor

2.1、延迟执行任务

那么我们用ScheduledThreadPoolExecutor改造上面的示例，看看是否解决之前的问题？

import lombok.extern.slf4j.Slf4j;

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

@Slf4j(topic = "c.TestScheduledThreadPool01")
public class TestScheduledThreadPool01 {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        log.debug("start...");
        pool.schedule(() -> {
            log.debug("task 1...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("task 1 continue...");
            int i = 1 / 0;
            log.debug("task 1 end...");
        }, 1, TimeUnit.SECONDS);

        pool.schedule(() -> {
            log.debug("task 2...");
        }, 1, TimeUnit.SECONDS);
    }
}
// 输出
2021-12-16 09:27:27.703 DEBUG [main] c.TestScheduledThreadPool01 - start...
2021-12-16 09:27:28.752 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool01 - task 1...
2021-12-16 09:27:28.752 DEBUG [pool-2-thread-2] c.TestScheduledThreadPool01 - task 2...
2021-12-16 09:27:30.756 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool01 - task 1 continue...

我们发现问题得到解决，注意：如果线程池线程数设置为1 那么任务换是会串行执行。

但是我们又发现，明明任务1会出现执行异常，我们没有处理异常，但是异常不见了，并且任务没有结束，那么如何处理线程池异常呢？

2.2、定时执行任务

  • scheduleAtFixedRate(任务, 初始延时, 执行周期, 时间单位)：执行周期就是每隔多次时间执行任务

  • scheduleWithFixedDelay(任务, 初始延时, 任务间隔, 时间单位)：任务间隔为上次执行任务到本次执行任务之间的时间差

  • 示例：

    import lombok.extern.slf4j.Slf4j;

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

@Slf4j(topic = "c.TestScheduledThreadPool02")
public class TestScheduledThreadPool02 {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(2);
        log.debug("start...");
        method1(pool);

    }

    public static void method1(ScheduledExecutorService pool) {
        pool.scheduleAtFixedRate(() -> {
            log.debug("task 1 running...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 1, 1, TimeUnit.SECONDS);
    }

    public static void method2(ScheduledExecutorService pool) {

        pool.scheduleWithFixedDelay(() -> {
            log.debug("task 2 running...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 1, 1, TimeUnit.SECONDS);
    }


}

// 方法1输出结果
2021-12-16 09:46:05.269 DEBUG [main] c.TestScheduledThreadPool02 - start...
2021-12-16 09:46:06.343 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool02 - task 1 running...
2021-12-16 09:46:08.348 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool02 - task 1 running...
2021-12-16 09:46:10.354 DEBUG [pool-2-thread-2] c.TestScheduledThreadPool02 - task 1 running...
// 方法2输出结果
2021-12-16 09:49:49.959 DEBUG [main] c.TestScheduledThreadPool02 - start...
2021-12-16 09:49:51.015 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool02 - task 2 running...
2021-12-16 09:49:54.024 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool02 - task 2 running...
2021-12-16 09:49:57.033 DEBUG [pool-2-thread-2] c.TestScheduledThreadPool02 - task 2 running...
    • 可以发现方法1任务间隔为2s，方法2任务间隔为3s

3、线程池异常处理

  • 方式1：任务自身处理异常，用try…catch…处理异常

  • 方式2：如果自己不处理，可以借助Future对象处理

  • 示例：

    import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.*;

@Slf4j(topic = "c.TestScheduledThreadPool01")
public class TestScheduledThreadPool03 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
        log.debug("start...");
        ScheduledFuture<?> future = pool.schedule(() -> {
            log.debug("task 1...");
            int i = 1 / 0;
            return true;
        }, 1, TimeUnit.SECONDS);
        System.out.println(future.get());
    }
}
// 输出
2021-12-16 09:56:21.398 DEBUG [pool-2-thread-1] c.TestScheduledThreadPool01 - task 1...
Exception in thread "main" java.util.concurrent.ExecutionException:

4、定时任务应用

需求：我们系统需要每周4 4:00:00点定时维护，那么该如何做呢？

分析：

  1. 我们使用scheduleAtFixedRate方法

  2. 可以确定是任务周期为1周，那么初始延迟和时间单位如何确定呢？

  3. 既然任务周期为1周，那么我们需要知道当前时间和周4的时间间隔，即初始延时

  4. 当前时间可能在本周的周4之前，也可能之后。

  5. 为方便时间计算，我们用LocalDateTime类，既然要计算时间，那么单位为毫秒

代码：

import lombok.extern.slf4j.Slf4j;

import java.time.DayOfWeek;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 定期维护：每周4 4:00:00执行维护工作
 * @author Administrator
 */
@Slf4j(topic = "c.RegularMaintenance")
public class RegularMaintenance {
    public static void main(String[] args) {
        // 1、获取当前时间
        LocalDateTime now = LocalDateTime.now();
        // 2、确定第一个周4的时间
        LocalDateTime time = now.withHour(4).withMinute(0).withSecond(0).withNano(0).with(DayOfWeek.THURSDAY);
        // 如果当前时间晚于本周4 4:00:00,那么计算得出的时间在延后1周即可
        if (now.compareTo(time) > 0) {
            time = time.plusWeeks(1);
        }
        // 3、执行定时任务
        long initialDelay = Duration.between(now, time).toMillis();
        long period = 7 * 24 * 3600 * 1000;
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
        pool.scheduleAtFixedRate(() -> {
            log.debug("定时维护任务开始执行...");
            log.debug("定时维护任务结束...");
        }, initialDelay, period, TimeUnit.MILLISECONDS);
    }
}

参考视频：https://www.bilibili.com/video/BV16J411h7Rd 224~229

源代码仓库地址：https://gitee.com/gaogzhen/concurrent

gaog2zh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java计划任务：ScheduledThreadPoolExecutor
liinux-Talk is cheap,show me the code.
07-11 447
自JDK 1.5 开始，JDK提供了ScheduledThreadPoolExecutor类用于计划任务（又称定时任务），这个类有两个用途： 在给定的延迟之后运行任务 周期性重复执行任务 在这之前，是使用Timer类来完成定时任务的，但是Timer有缺陷： Timer是单线程模式； 如果在执行任务期间某个TimerTask耗时较久，那么就会影响其它任务的调度； Timer的任务调度是基于绝对时间的，对系统时间敏感； Timer不会捕获执行TimerTask时所抛出的异常，由于Timer是单线程，
ScheduledThreadPoolExecutor Java
huzuoliang
03-08 425
Java提供的Time类可以周期性地或者延期执行任务，但是有时我们需要并行执行同样的任务，这个时候如果创建多个Time对象会给系统带来负担，解决办法是将定时任务放到线程池中执行。Java的ScheduledThreadPoolExecutor类实现了ScheduledExecutorService接口中定义的以不同方法执行任务的方法。Executors类提供了工厂方法创建ScheduledThrea
Java 线程池之 ScheduledThreadPool
最新发布
yimeixiaolangzai的博客
07-05 538
是 Java 并发包（）中的一种线程池实现，它能够调度任务在指定延迟后或周期性地执行。与传统的Timer类相比，提供了更高的灵活性和更好的性能，尤其是在需要同时调度多个任务时。除了使用Executors工具类，还可以通过// 自定义参数 customScheduledThreadPool . setKeepAliveTime(10 , TimeUnit . SECONDS);
Java 并发编程之线程池 ScheduledThreadPool
风香枫
04-18 431
ScheduledThreadPool 为定时任务线程池 1）定义任务线程 public class Task implements Runnable { private String name; Task(String name) { this.name = name; } @Override public void run() { System.out.println(Thread.currentThread(...
java 线程池之 newScheduledThreadPool
比嗨皮兔
01-29 9323
线程的实现方式 java 多线程之 extends Thread java 多线程之 implements Runnable java 多线程之 implements Callable 线程池的使用 线程池简介 ThreadPoolExecutor java 线程池之 newScheduledTh......
java多线程学习-java.util.concurrent详解(三)ScheduledThreadPoolExecutor
行风
05-27 1386
from: http://janeky.iteye.com/blog/770441 6. ScheduledThreadPoolExecutor 我们先来学习一下JDK1.5 API中关于这个类的详细介绍： "可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求 ThreadPoolExecutor 具有额外的灵活性或功能时，此类要优于 Timer。
Java进阶高手课-并发编程透彻理解
06-20
在Java世界中，并发编程是不可或缺的一个重要领域，尤其对于经验丰富的开发者来说，掌握并发编程技巧是提升效率、优化系统性能的关键。"Java进阶高手课-并发编程透彻理解"这一课程旨在深入剖析Java并发编程的核心...
Java并发编程学习笔记
04-11
Java并发编程是Java开发中必不可少的一部分，涉及到多线程、同步机制、线程池以及并发工具类等多个核心知识点。以下是对这些主题的详细说明： 1. **线程安全与锁 Synchronized 底层实现原理**： 线程安全是指在多...
浅谈Java并发编程基础知识
08-25
Java并发编程基础知识 Java并发编程是指在Java语言中，通过使用多线程、线程池、锁机制、原子变量等技术来实现并发编程的基础知识。本文将对Java并发编程的基础知识进行讲解，包括进程和线程、线程生命周期、线程...
java-concurrency编程内部分享.zip_java-concurrency
09-21
这份“java-concurrency编程内部分享”压缩包包含了关于Java并发编程的一份PPT，它可能涵盖了以下几个关键知识点： 1. **线程与进程**：首先，会讲解线程和进程的基本概念，它们的区别和联系。在Java中，线程是执行...
JAVA 定时器 ScheduledThreadPoolExecutor
javaEE 专栏 + 琐事小计
06-13 191
[code="java"] ... //定时器 ScheduledThreadPoolExecutor monitorService = new ScheduledThreadPoolExecutor(10, new ThreadFactoryBuilder().setNameFormat("lifecycleSupervisor-" + Thread.currentThread()...
Java并发--ScheduledThreadPoolExecutor
吴声子夜歌的博客
01-22 615
ScheduledThreadPoolExecutor ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor的功能与Timer类似，但ScheduledThreadPoolExecutor功能更强大、更灵活。 Timer对应的是单个后台线程，而S...
JAVA多线程实现-支持定时与周期性任务的线程池(newScheduledThreadPool)
山禾园地
03-30 9595
前几篇文章中分别介绍了单线程化线程池(newSingleThreadExecutor)可控最大并发数线程池(newFixedThreadPool)可回收缓存线程池(newCachedThreadPool)newScheduledThreadPool用于构造安排线程池，能够根据需要安排在给定延迟后运行命令或者定期地执行。在JAVA文档的介绍public static ScheduledExecuto...
Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor...
dielucuan8830的博客
09-22 90
1、new Thread的弊端 执行一个异步任务你还只是如下new Thread吗？ Java 1 new Thread(new Runnable() { 2 3 @Override 4 public void run() { 5 // TODO Auto-generated method stub 6 } 7 }).start(); 那你就...
Java并发编程之线程定时器ScheduledThreadPoolExecutor解析
qq_40874285的博客
05-01 3010
定时器 就是需要周期性的执行任务，也叫调度任务，在JDK中有个类Timer是支持周期性执行，但是这个类不建议使用了。 ScheduledThreadPoolExecutor 继承自ThreadPoolExecutor线程池，在Executors默认创建了两种： newSingleThreadScheduledExecutor：只包含一个线程，只需要单个线程执行周期任务，保证顺序的执行各个任务。 newScheduledThreadPool： 可以包含多个线程的，线程执行周期任务，适度控制后台线程数
Java并发之ScheduleThreadPoolExecutor
ZCC的专栏
05-11 639
一、ScheduleThreadPoolExecutor 简介 ScheduledThreadPoolExecutor 扩展了 ThreadPoolExecutor 类，并且添加了其它方法实现了ScheduledExecutorService 接口。 schedule() 方法允许在指定的延迟后执行一次任务 scheduleAtFixedRate() 方法允许在指定的初始延迟后执行任务，然后以一定的周期重复执行，其中 period 参数用于指定两个任务的开始时间之间的间隔时间，因此任务执行的频率是固定
newscheduledthreadpool java_Java四种线程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,n...
weixin_34732771的博客
03-01 758
1.newCachedThreadPool创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程， 那么就会回收部分空闲(60秒不执行任务)的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。2.newFixedThreadPool创建固定大小的线程池。每次提交一个任务就创...
newscheduledthreadpool java_java 线程池之 newScheduledThreadPool-Go语言中文社区
weixin_40001275的博客
03-01 285
newScheduledThreadPool 和 其他线程池最大的区别是使用的阻塞队列是 DelayedWorkQueue，而且多了两个定时执行的方法scheduleAtFixedRate和scheduleWithFixedDelaypublic ScheduledThreadPoolExecutor(int corePoolSize) {super(corePoolSize, Integer.M...
java线程池（四）之newScheduledThreadPool
weixin_44613100的博客
06-07 1139
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
Java并发编程核心技术：ScheduledThreadPoolExecutor详解
在 Java 中，定时任务和线程池是并发编程的关键组件。 ScheduledThreadPoolExecutor 类是 Java 中的核心类之一，用于处理延时任务或定时任务。下面将详细介绍 ScheduledThreadPoolExecutor 类的结构和工作原理，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

gaog2zh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值