并发编程之定时任务&定时线程池

最新推荐文章于 2024-09-02 14:45:02 发布
最新推荐文章于 2024-09-02 14:45:02 发布
阅读量1.6k 收藏 3
点赞数
分类专栏： Java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41931364/article/details/120724381
版权

java

并发编程之定时线程池&定时任务

1、定时线程池

1.1、定时线程池的由来

ScheduledThreadPoolExecutor定时线程池是继承自 ThreadPoolExecutor 类和实现了 ScheduledExecutorService类。
如下图所示：

在这里插入图片描述

1.2、ScheduledThreadPoolExecutor的api

1.2.1、schedule

schedule api是将任务延迟执行，如下面代码，run方法里面的代码将会在线程启动后5s后执行，代码如下：

private static Logger logger = Logger.getLogger(Log.class.getName());
public static void main(String[] args) {
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    logger.info("开始的时候！");
    
    scheduledThreadPoolExecutor.schedule(new Runnable() {
        @Override
        public void run() {
            logger.info("我要延迟5s执行！");
        }
    },5000, TimeUnit.MILLISECONDS);
}

程序执行结果截图：
17s = => 22s

在这里插入图片描述

1.2.2、scheduleAtFixedRate

它有两个参数，
第一个参数是线程再启动后延迟多长执行
第二个参数是循环执行的周期是多长时间
下面这个就是在线程启动后延迟一秒，然后以两秒的周期循环执行

private static Logger logger = Logger.getLogger(Log.class.getName());
public static void main(String[] args) {
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    logger.info("开始的时候！");
    
    scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            logger.info("执行。。。。");
        }
    },1000,2000,TimeUnit.MILLISECONDS);
}

执行结果去下图所示：

在这里插入图片描述

问题：如果任务执行的时间大于间隔周期的时间怎么办？

任务会在阻塞队列里面排队，当上一个任务执行完成之后刚空出来就会去执行下一个任务，代码如下所示：

private static Logger logger = Logger.getLogger(Log.class.getName());
public static void main(String[] args) {
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    logger.info("开始的时候！");

    scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            logger.info("执行。。。。");
            long start = System.currentTimeMillis();
            while(true){
                long end = System.currentTimeMillis();
                if(end - start > 5000){
                    break;
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    },1000,2000,TimeUnit.MILLISECONDS);
}

执行结果如下图所示：

在这里插入图片描述

注意：这里虽然是5秒执行一个任务，但是在阻塞队列中一定排了很多任务，即使我们将线程池扩大，也无济于事，因为我们一个任务只能由一个线程执行。

1.2.3、scheduleWithFixedDelay

由于在很多时候我们不知道一个任务到底能执行多长时间，所以就有了下面这个api，就是当我们上一个任务执行完成之后，再间隔一段时间去进行下一次循环，代码如下所示：

private static Logger logger = Logger.getLogger(Log.class.getName());
public static void main(String[] args) {
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    logger.info("开始的时候！");

    scheduledThreadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
            logger.info("执行。。。。");
            long start = System.currentTimeMillis();
            while(true){
                long end = System.currentTimeMillis();
                if(end - start > 5000){
                    break;
                }
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    },1000,2000,TimeUnit.MILLISECONDS);
}

执行截图如下所示：
任务基本7s执行一次

在这里插入图片描述

1.3、定时线程池应用场景

1、Redis的分布式锁
如果我们的一个Redis有很多的客户端，当一个客户端拿到一个锁之后，突然挂掉了，这个时候我们这个锁资源会有一个过期时间，正常情况下是可以满足的，但是如果说我们这块的业务逻辑比较复杂的话，这个过期时间还不够，那么就会存在别的线程获取到当前锁资源的情况，所以这个时候就可以用到我们的这个定时线程池了，我们这个定时线程池在隔一段时间检测一下这个锁，如果还存在就给他续上几秒，直至这个锁被释放，这样，就无论你这个任务执行多久，都会保证把这个任务执行完之后，锁才会释放。

2、zk注册中心与服务发现
当我们的项目是微服务架构的话，我们每个系统只用去访问zk，zk会根据我们上送的服务名去自动分配活着的相应服务，而这些活着的服务信息是怎么来的呢，就是他们会每隔一段时间将自己的配置信息等情况发送给zk，zk拿到之后做管理，后续再相应其它服务的分配。这种隔一段时间就上送自己信息的方式就可以用ScheduledThreadPoolExecutor定时线程池做。

3、定期刷新缓存等等。

2、定时线程池源码简析

下面我以scheduleAtFixedRate api举例，其它的都差不多
首先我们进入到这个方法

2.1、scheduleAtFixedRate

scheduleAtFixedRate的构造方法
1、对任务进行排序。
2、将任务存储起来。
3、走延时执行方法。

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    if (period <= 0)
        throw new IllegalArgumentException();
    // 通过内部的一个包装，实现任务的排序，排序的方式是堆
    ScheduledFutureTask<Void> sft =
        new ScheduledFutureTask<Void>(command,
                                      null,
                                      triggerTime(initialDelay, unit),
                                      unit.toNanos(period));
    // 里面什么都没干，留给拓展用
    RunnableScheduledFuture<Void> t = decorateTask(command, sft);
    // 将当前任务存储在 outerTask 成员变量中
    sft.outerTask = t;
    // 执行延时执行
    delayedExecute(t);
    return t;
}

2.2、delayedExecute

延时执行方法
1、如果线程池已挂掉，执行拒绝策略。
2、将任务放进队列中，再次判断线程池的状态，如果没问题，则找线程执行。

private void delayedExecute(RunnableScheduledFuture<?> task) {
	// 如果线程池已挂掉，执行拒绝策略
    if (isShutdown())
        reject(task);
    else {
    	// 否则，将任务直接放在队列中
        super.getQueue().add(task);
        // 再次判断线程池的状态是否有问题
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
        	// 若没有问题，创建线程，来执行任务
            ensurePrestart();
    }
}

2.3、ensurePrestart

主要就是创建线程去执行任务

void ensurePrestart() {
	// 取出线程池中的线程数量
    int wc = workerCountOf(ctl.get());
    // 如果小于核心线程数，创建一个核心线程来执行任务
    if (wc < corePoolSize)
        addWorker(null, true);
    // 工作线程都等于0了还没有核心线程数大，那核心线程数的配置也只能是0了
    // 能走到这块说明核心线程数参数为0，但是任务还是要执行，所以启动一个非核心线程
    else if (wc == 0)
        addWorker(null, false);
    // 表示核心线程已经创建满，则等待核心线程腾出来再执行，因为前面已经加入到队列里了
}

2.4、ScheduledThreadPoolExecutor的run方法

在addWorker里面进行一系列的状态判断，最终启动线程，由于刚才在创建线程的时候传入的参数为this，所以需要执行ScheduledThreadPoolExecutor里面的run方法。

public void run() {
	// 取出周期值
    boolean periodic = isPeriodic();
    // 判断当前线程的状态是否正常
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    // 如果不是周期的走这个，只执行一次的那种
    else if (!periodic)
        ScheduledFutureTask.super.run();
    // 如果是周期的，走这个，循环执行的那种
    // ScheduledFutureTask.super.runAndReset() 执行具体任务并重置
    else if (ScheduledFutureTask.super.runAndReset()) {
    	// 下一次执行时间
        setNextRunTime();
        // 为下一次执行做准备
        reExecutePeriodic(outerTask);
    }
}

2.5、reExecutePeriodic

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(true)) {
        	// 添加到队列
            super.getQueue().add(task);
            // 判断线程状态是否正常
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
            	// 继续走2.3
                ensurePrestart();
        }
    }

10、辅助知识

10.1、当任务中抛出异常时各定时任务的处理

10.1.1、ScheduledThreadPoolExecutor的处理

private static Logger logger = Logger.getLogger(Log.class.getName());
public static void main(String[] args) {
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    logger.info("开始的时候！");

    scheduledThreadPoolExecutor.scheduleWithFixedDelay(new Runnable() {
        @Override
        public void run() {
            logger.info("执行。。。。");
            throw new RuntimeException();
        }
    },1000,2000,TimeUnit.MILLISECONDS);
}

执行截图如下：
我们会发现线程就卡在这里了，这是因为在线程池底层给我们把异常捕获到，然后另外创建了一个线程，虽然说线程池还存在，线程也存在，但是任务却被丢弃了，所以显示就是卡在这里了。

在这里插入图片描述

10.1.2、Timer的处理

代码示例如下：

private static Logger logger = Logger.getLogger(Log.class.getName());
public static void main(String[] args) {
    ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(1);
    logger.info("开始的时候！");

    Timer timer = new Timer();
    timer.scheduleAtFixedRate(new TimerTask() {
        @Override
        public void run() {
            logger.info("执行。。。。");
            throw new RuntimeException();
        }
    },1000,2000);
}

执行截图如下：

在这里插入图片描述

我们会发现直接报错了，程序都已经停止运行了，因为它直接把线程给了一个成员变量，所以抛出了一个异常导致问题挺严重的，所以很多规范也不提倡我们用Timer。

小乐乐的天台
关注
专栏目录
Java 线程池的使用【三】【ScheduledThreadPoolExecutor】
单枪匹码
05-03 2444
一、ScheduledThreadPoolExecutor： 1、简介： ScheduledThreadPoolExecutor可以用来：在给定延时后执行异步任务或者周期性执行任务，JDK5.0之前都是使用Timer或TimerTask来处理定时任务，相对于任务调度的Timer来说，其功能更加强大，Timer只能使用一个后台线程执行任务，而ScheduledThreadPoolExecutor则可以通过构造函数来指定后台线程的个数。 Timer和TimerTask存在的一些缺陷：Timer只创建了一个线程，
Spring Boot中配置定时任务、线程池与多线程池执行的方法
08-25
主要给大家介绍了关于Spring Boot中配置定时任务、线程池与多线程池执行的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring Boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
[线程] 定时器 及 实现定时器
最新发布
m0_73992740的博客
09-02 924
把这些任务通过优先级队列保存起来, 按照时间作为优先级的先后标准, 就可以做到, 队首元素就是时间最靠前的任务, 那么执行任务的时候, 只需要取队首元素即可。因为我们要实现的是小根堆, 在compareTo方法中, 是 谁 - 谁, 我们不要去背, 随便写一个试试就知道对不对了, 背很容易背错!指定一个任务(Runnable), 并且指定一个时间, 此时这个任务不会立即执行, 而是在时间到达后, 再去执行。如果是delay, 随着时间的推移, 还需要更新delay, 比较麻烦。
SpringBoot中使用动态定时任务+CRON+多线程（线程池）
丨史丨努丨指丨
04-30 3959
SpringBoot + 动态设置CRON + 多线程
并发之定时任务线程池
热门推荐
xueguchen的博客
06-04 2万+
1.ScheduledThreadPoolExecutor 作用 指定延时后执行任务 周期性重复执行任务 2. ScheduledThreadPoolExecutor 类结构图 3. ScheduledThreadPoolExecutor的运行机制 注意： DelayQueue是无界队列（maximumPoolSize参数无效）；DelayQueue内部封装了一个PriorityQueue，它会根据time的先后时间排序，若time相同则根据sequenceNumber排序 流程： 当调用Sche
java基于线程池和反射机制实现定时任务完整实例
09-03
在Java编程中，定时任务是应用中常见的需求，如定期数据同步、日志清理等。本实例通过结合线程池和反射机制来实现一个灵活、可扩展的...通过学习和理解这个实例，开发者可以更好地理解和运用Java的并发编程和反射特性。
java定时线程池怎么关闭_Java定时线程池停止超时任务
weixin_31889705的博客
03-03 1164
一、背景题主最近遇到一个问题，本来通过ScheduledExecutorService线程池定时调度一个任务。奈何不知道为啥跑了2个多月，其中一个任务Hang住了，原本定时的任务则出现了问题。关于定时线程池，好多人认为设置好频率(比如1Min)，它会按照这个间隔按部就班的工作。但是，如果其中一次调度任务卡住的话，不仅这次调度失败，而且整个线程池也会停在这次调度上。我们先从一个例子试着复现下问题：p...
Java并发（七）异步执行任务之手写线程池、定时任务、CompletableFuture
08-23 1255
手写 表示子任务： public interface Callable<V> { V call() throws Exception; } 表示异步调用的结果： public interface MyFuture <V> { V get() throws Exception ;//返回真正的结果，如果结果还没有计算完成，get会阻塞直到计算完成，如果调用过...
线程池、任务、任务组、任务池，定时任务的类库-hy.common.tpool.zip
11-06
总的来说，`hy.common.tpool`库是针对线程池、任务、任务组和定时任务的一种实现，对于理解和使用Java并发编程，以及提高多线程应用的性能和稳定性有着重要的参考价值。通过研究这个库，开发者可以更好地理解和掌握...
并发编程之线程池原理
疾风先生的博客
02-06 352
1. 线程池作用 使用背景 在并发大量异步任务处理程序中,每执行一个任务就需要创建一个线程,同时任务执行完毕之后需要将线程销毁.我们知道JVM创建线程的时候需要为其分配线程栈空间以及一些初始化操作,同时销毁的过程需要回收线程栈空间并由gc释放资源,期间都需要耗费一定的时间,因此一个任务的最终执行时间=创建线程newTime + 程序执行excuteTime + 线程销毁的gcTime,如果期...
定时线程池
qq_44447372的博客
02-11 2529
目录 定时线程池基本介绍 ScheduledThreadPoolExecutor介绍 ScheduledExecutorService介绍 阻塞队列使用的是DelayedWorkQueue() 常用的定时任务区别 定时线程池基本介绍 用来处理延迟任务或者定时任务 与ThreadPoolExecutor不同的是里面没有非核心线程概念(ThreadPoolExecutor的有关知识可以点击此链接查看) 它接受ScheduledFutureTask类型的任务,是线程调度任务的最小单位,..
并发编程之定时线程池&DCL
wmburst
06-02 240
定时任务ScheduledThreadPoolExecutor： 介绍： 之前我们讲的ThreadPoolExecutor是java的普通线程池。而ScheduledThreadPoolExecutor是java提供的定时任务线程池。 使用： 常用 java.util.concurrent.ScheduledThreadPoolExecutor#schedule 定时任务 java.util.concurrent.ScheduledThreadPoolExecutor#scheduleAtFixedRate
Java-什么是定时任务线程池？
兴趣是最好的老师
08-21 194
创建定时任务线程池：使用 Executors.newScheduledThreadPool() 方法创建一个定时任务线程。提交任务：使用 scheduleAtFixedRate 方法提交任务到线程池，该任务每隔一秒执行一次。提交任务：使用 scheduleAtFixedRate 方法提交任务到线程池，该任务每隔一秒执行一次。关闭线程池：使用 shutdown 方法关闭线程池，并等待所有任务完成。下面是一个使用上述工具类创建定时任务线程池并执行任务的示例。建定时任务线程池，这里设置了线程池大小为 3。
定时线程池（newScheduledThreadPool）
qq_37365741的博客
01-08 7037
定时线程池（newScheduledThreadPool） package com.zhw.learning.thread; import java.text.SimpleDateFormat; import java.util.Date; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledEx...
定时执行的线程池
架构师与哈苏
08-04 204
private static void scheduled(){ //创建一个定时执行的线程池 ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3); scheduledExecutorService.schedule(() -> { Syste...
定时线程池ScheduledThreadPool
qq_33635619的博客
04-03 1188
1、定长线程池 ScheduledExecutorService es = Executors.newScheduledThreadPool(1); 1代表线程池的大小。 2、用法 // 线程一 es.scheduleAtFixedRate(() -> { try{ System.out.println("###############...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值