定时线程池执行器

最新推荐文章于 2024-04-18 21:13:54 发布
最新推荐文章于 2024-04-18 21:13:54 发布
阅读量298 收藏 1
点赞数
文章标签： java 算法 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/taoyuan1377/article/details/123827208
版权

一、基础知识的补充

@Slf4j
public class ConditionTest {
    private static ReentrantLock reentrantLock = new ReentrantLock();
    private static final Condition available = reentrantLock.newCondition();
    public static void main(String[] args) {
        for(int i = 0 ; i < 10; i++){
            int finalI = i;
            new Thread(()->{
                reentrantLock.lock();
                try {
                    System.out.println("正在执行" + finalI);
                    available.await(1, TimeUnit.MINUTES);
                    System.out.println("执行完成....");
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    System.out.println("解锁");
                    reentrantLock.unlock();
                }
            }).start();
        }
    }
}

执行结果：

正在执行0
正在执行1
正在执行9
正在执行2
正在执行3
正在执行4
正在执行5
正在执行6
正在执行7
正在执行8
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁
执行完成....
解锁

Process finished with exit code 0

得出的结论：await()方法挂起当前线程并释放锁

二、定时线程池类的类结构图

 它用来处理延时任务或定时任务。

它接收SchduledFutureTask类型的任务，是线程池调度任务的最小单位，有三种提交任务的方式：

  1. schedule
  2. scheduledAtFixedRate
  3. scheduledWithFixedDelay

它采用DelayQueue存储等待的任务

  1. DelayQueue内部封装了一个PriorityQueue，它会根据time的先后时间排序，若time相同则根据sequenceNumber排序；
  2. DelayQueue也是一个无界队列；

三、SchduledFutureTask的源码解析

SchduledFutureTask接收的参数(成员变量)：

private long time：任务开始的时间
private final long sequenceNumber;：任务的序号
private final long period：任务执行的时间间隔

工作线程的执行过程：

  • 工作线程会从DelayQueue取已经到期的任务去执行；
  • 执行结束后重新设置任务的到期时间，再次放回DelayQueue

ScheduledThreadPoolExecutor会把待执行的任务放到工作队列DelayQueue中，DelayQueue封装了一个PriorityQueue，PriorityQueue会对队列中的ScheduledFutureTask进行排序，具体的排序算法实现如下：

public int compareTo(Delayed other) {
	if (other == this) // compare zero if same object
		return 0;
	if (other instanceof ScheduledFutureTask) {
		ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
		long diff = time - x.time;
		if (diff < 0)
			return -1;
		else if (diff > 0)
			return 1;
		else if (sequenceNumber < x.sequenceNumber)
			return -1;
		else
			return 1;
	}
	long diff = getDelay(NANOSECONDS) - other.getDelay(NANOSECONDS);
	return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
}
  1. 首先按照time排序，time小的排在前面，time大的排在后面；
  2. 如果time相同，按照sequenceNumber排序，sequenceNumber小的排在前面，sequenceNumber大的排在后面，换句话说，如果两个task的执行时间相同，优先执行先提交的task。

SchduledFutureTask之run方法实现

run方法是调度task的核心，task的执行实际上是run方法的执行。

public void run() {
    boolean periodic = isPeriodic();
    //如果当前线程池已经不支持执行任务，则取消
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    //如果不需要周期性执行，则直接执行run方法然后结束
    else if (!periodic)
        ScheduledFutureTask.super.run();
    //如果需要周期执行，则在执行完任务以后，设置下一次执行时间
    else if (ScheduledFutureTask.super.runAndReset()) {
        // 计算下次执行该任务的时间
        setNextRunTime();
        //重复执行任务
        reExecutePeriodic(outerTask);
    }
}
  1. 如果当前线程池运行状态不可以执行任务，取消该任务，然后直接返回，否则执行步骤2；
  2. 如果不是周期性任务，调用FutureTask中的run方法执行，会设置执行结果，然后直接返回，否则执行步骤3；
  3. 如果是周期性任务，调用FutureTask中的runAndReset方法执行，不会设置执行结果，然后直接返回，否则执行步骤4和步骤5；
  4. 计算下次执行该任务的具体时间；
  5. 重复执行任务。

reExecutePeriodic方法

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
    if (canRunInCurrentRunState(true)) {
        super.getQueue().add(task);
        if (!canRunInCurrentRunState(true) && remove(task))
            task.cancel(false);
        else
            ensurePrestart();
    }
}

该方法和delayedExecute方法类似，不同的是：

  1. 由于调用reExecutePeriodic方法时已经执行过一次周期性任务了，所以不会reject当前任务；
  2. 传入的任务一定是周期性任务。

线程池任务的提交

首先是schedule方法，该方法是指任务在指定延迟时间到达后触发，只会执行一次。

public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit) {
    //参数校验
    if (command == null || unit == null)
        throw new NullPointerException();
    //这里是一个嵌套结构，首先把用户提交的任务包装成ScheduledFutureTask
    //然后在调用decorateTask进行包装，该方法是留给用户去扩展的，默认是个空方法
    RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                      triggerTime(delay, unit)));
    //包装好任务以后，就进行提交了
    delayedExecute(t);
    return t;
}

任务提交方法：

private void delayedExecute(RunnableScheduledFuture<?> task) {
    //如果线程池已经关闭，则使用拒绝策略把提交任务拒绝掉
    if (isShutdown())
        reject(task);
    else {
    //与ThreadPoolExecutor不同，这里直接把任务加入延迟队列
        super.getQueue().add(task);//使用用的DelayedWorkQueue
    //如果当前状态无法执行任务，则取消
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
    //这里是增加一个worker线程，避免提交的任务没有worker去执行
    //原因就是该类没有像ThreadPoolExecutor一样，woker满了才放入队列
          ensurePrestart();
    }
}

DelayedWorkQueue

        ScheduledThreadPoolExecutor之所以要自己实现阻塞的工作队列，是因为ScheduledThreadPoolExecutor要求的工作队列有些特殊。

        DelayedWorkQueue是一个基于堆的数据结构，类似于DelayQueue和PriorityQueue。在执行定时任务的时候，每个任务的执行时间都不同，所以DelayedWorkQueue的工作就是按照执行时间的升序来排列，执行时间距离当前时间越近的任务在队列的前面（注意：这里的顺序并不是绝对的，堆中的排序只保证了子节点的下次执行时间要比父节点的下次执行时间要大，而叶子节点之间并不一定是顺序的 ）。

四、扩展：

xxljob:

集成xxljob的项目，首先会有这么一段配置：

 @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);

        return xxlJobSpringExecutor;
    }

XxlJobSpringExecutor 实现了SmartInitializingSingleton的接口，当所有单例 bean 都初始化完成以后， Spring的IOC容器会回调该接口的 afterSingletonsInstantiated()方法：

1、会将带有XxlJob注解的方法注册到容器中，key为XxlJob的value，value为MethodJobHandler。

2、使用了Netty的Http通信，然后启动了服务器端

xxljob-admin会和服务端进行通信：

1、创建一个线程scheduleThread，执行调度任务，是daemon线程：

1） 使用悲观锁，进行分布式锁，这样即时有多个xxljob-admin也只会有一台执行：

select * from xxl_job_lock where lock_name = 'schedule_lock' for update

2）获取小于等于下次执行时间在5秒后的任务

SELECT <include refid="Base_Column_List" />
		FROM xxl_job_info AS t
		WHERE t.trigger_status = 1
			and t.trigger_next_time <![CDATA[ <= ]]> #{maxNextTime}
		ORDER BY id ASC
		LIMIT #{pagesize}

3）然后判断 当前任务的时间是否在5秒内，如果不在则放弃执行，

当前是10:00:00， trigger_next_time = 9:59:54 则直接放弃，其他情况将需要执行的作业根据执行时间取模并写入到一个Map结构中，即ringData

int ringSecond = (int)((jobInfo.getTriggerNextTime()/1000)%60);
List<Integer> ringItemData = ringData.get(ringSecond);
if (ringItemData == null) {
    ringItemData = new ArrayList<Integer>();
    ringData.put(ringSecond, ringItemData);
}
ringItemData.add(jobId);

2、创建一个线程ringThread

不断循环获取ringItemData集合的数据，通过线程池执行任务：通过jobId获取任务，然后根据任务的jobGroup获取XxlJobGroup

SELECT <include refid="Base_Column_List" />
		FROM xxl_job_info AS t
		WHERE t.id = #{id}
SELECT <include refid="Base_Column_List" />
		FROM xxl_job_group AS t
		WHERE t.id = #{id}

向xxl-job-admin发执行任务的消息http://adress/run，请求参数：

TriggerParam triggerParam = new TriggerParam();
triggerParam.setJobId(jobInfo.getId());
triggerParam.setExecutorHandler(jobInfo.getExecutorHandler());
triggerParam.setExecutorParams(jobInfo.getExecutorParam());
triggerParam.setExecutorBlockStrategy(jobInfo.getExecutorBlockStrategy());
triggerParam.setExecutorTimeout(jobInfo.getExecutorTimeout());
triggerParam.setLogId(jobLog.getId());
triggerParam.setLogDateTime(jobLog.getTriggerTime().getTime());
triggerParam.setGlueType(jobInfo.getGlueType());
triggerParam.setGlueSource(jobInfo.getGlueSource());
triggerParam.setGlueUpdatetime(jobInfo.getGlueUpdatetime().getTime());
triggerParam.setBroadcastIndex(index);
triggerParam.setBroadcastTotal(total);

程序员一护
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java 定时执行任务
04-14
Java定时执行任务是Java开发中常见的一种需求，用于在特定时间点或按照预设周期执行某段代码。在Java中，有两种主要的方式来实现定时任务：Java.util.Timer类和java.util.concurrent包下的ScheduledExecutorService...
Java 线程池框架
08-31
4. **ScheduledThreadPoolExecutor**：与前三个不同，它可以定时或周期性执行任务，适用于需要定期调度的任务，如定时任务、延迟执行等。 三、线程池核心参数 1. **corePoolSize**：线程池的基本大小，即当线程池...
java线程池、定时任务
a123123sdf的博客
08-23 3172
目录标题一、自定义线程池二、java提供的四种线程池三、java定时任务 一、自定义线程池 参考 package threadPool; import java.util.Date; import java.util.concurrent.*; /** * * 自定义线程池。 * ThreadPoolExecutor<b>构造参数如下</b><br/> * * int corePoolSize, 核心线程大小(当前最大并行运行线程数)<br/>
线程池的使用-定时任务
好好学习
07-26 2071
线程池概念﹔ 其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。 线程池的底层原理 线程池的使用 线程池：JDK1.5之后提供的 Java.util.concurrent.Executors:线程池的工厂类，用来生成线程池 Executors类中的静态方法： static ExecutorService newFixedThreadPool（int nThreads）创建一个可重用固定线程数的线程池 参数： int nThreads：创建
【多线程】定时器 | 线程池 | 实现MyTimer | 实现MyThreadPoll | 工厂模式 | 构造方法 | 参数种类
最新发布
WengJM的博客
04-18 1583
​ 假设一个线程的所有代码都是CPU密集型代码，线程池中的线程数量不应该超过N(CPU核心数)，设置的比N大，cpu吃满了，无法提高效率，此时添加更多的线程反而增加调度的开销。换句话说，timer当中的任务，是有当中的扫描线程来执行的。所以在第一次判断时间时，在else中，当任务时间还没到的时候，进行wait阻塞，此时线程不会在CPU上调度，避免了忙等。​ 假设一个线程的所有代码都是IO密集型的，这个时候不吃CPU，此时设置的线程数，就可以超过N.一个核心可以通过调度的方式，来并发执行。
xxl-job远程命令执行漏洞复现
热门推荐
Bird&Bird
12-15 1万+
目录1、漏洞描述2、靶场搭建3、漏洞复现（反弹shell） 1、漏洞描述 XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。XXL-JOB分为admin和executor两端，前者为后台管理页面，后者是任务执行的客户端。executor默认没有配置认证，未授权的攻击者可以通过RESTful API执行任意命令。 2、靶场搭建 靶场使用vulhub 进入vulhub/xxl-job/unacc目录下，执行docker-
11.定时任务&定时线程池详解
Mao_yafeng的博客
10-27 6809
当我们不用任务框架时，我们想自己写一个定时任务时，我们能想起那个工具类呢？Timer ？还有吗？不知道了，下面我们要讲下ScheduledThreadPoolExecutor，定时任务线程池，可以执行一次任务，还可以执行周期性任务。
android线程池
01-19
三、单线程执行器（SingleThreadExecutor） SingleThreadExecutor由Executors的newSingleThreadExecutor方法创建。它保证所有任务都在同一个线程中顺序执行，确保了任务执行的顺序性和互斥性。适合于需要按顺序处理...
Spring Boot定时+多线程执行过程解析
08-25
在Spring Boot应用中，定时任务和多线程的结合使用能极大地提高程序的执行效率，尤其是在处理大量数据或长时间运行的任务时。以下是对Spring Boot定时任务和多线程执行过程的详细解析： 首先，Spring Boot提供了...
java定时任务，每天定时执行任务
06-06
Timer 是一个线程池，用于执行定时任务，而 TimerTask 是一个抽象类，用于定义定时任务的执行逻辑。在这个例子中，我们使用 Timer 和 TimerTask 实现了每天定时执行任务的功能。 知识点 2：Calendar 的使用 在这个...
12-面试官：如何使用线程池执行定时任务？
学习 记录 总结 分享
09-04 1704
线程池执行定时任务的实现方法有 3 个：使用 schedule 方法执行定时任务，只执行一次定时任务。使用 scheduleAtFixedRate 方法执行定时任务，执行多次定时任务，它的执行时间间隔是固定的，不受定时任务执行时长影响（定时任务时间间隔 > 任务执行时间）。使用 scheduleWithFixedDelay 方法执行定时任务，执行多次定时任务，它是在定时任务执行完之后，再隔 N 秒开始执行下一次定时任务，它的执行时间受定时任务执行时长影响。
线程池的创建方式和执行过程的理解
weixin_69397284的博客
02-15 512
线程池的创建方式和其工作流程
定时任务加线程池处理任务的几种方式
木仕的博客
02-03 1262
定时任务 + 线程池处理任务的集中方式
[Java备忘]定时任务线程池
mdwsmg的博客
05-29 1549
java自带定时任务线程池使用，ScheduledExecutorService
基于线程池的定时任务/控制一段代码的执行时间
日常记录
03-22 474
此时，如果你希望在Callable的while中控制任务的停止，你可以在while循环中判断Thread.currentThread().isInterrupted()，如果返回true，则代表任务已经被取消，可以退出while循环，终止任务的执行。调用shutdownNow()方法后，如果还有其他的任务在执行，那么它们也将被取消，并且shutdownNow()方法将会尝试停止正在执行的线程。在下面的例子中，监控你要执行的代码部分，如果这段代码执行的时间超过了你的定义，你可以终止它继续后面的代码。
【Executors】线程池的4种常见创建方式
我家有个小喵咪
04-26 1万+
这世界上没有优秀的理念，只有脚踏实地的结果 。 一、 创建缓存型线程池（CachedThreadPool） 1、定义： Executors.newCacheThreadPool()：可缓存线程池，先查看线程池中有没有之前创建的线程，如果有则直接使用。否则就新创建一个新的线程加入线程池中，我们经常用此类线程池来执行一些业务处理时间很短的任务。 2、示例代码： 情况1： public static void main(String[] args) { //......
使用线程池异步执行定时任务
Java学习博客
06-14 755
最近项目中需要做一个定时任务在某个固定的时间去执行一个任务，由于该定时任务的代码量已经超出可读性规范，并且处于性能的考虑，故使用线程池来做一个异步执行的方法。
ThreadPoolTaskScheduler和ThreadPoolTaskExecutor
qq_41067796的博客
07-14 1440
ThreadPoolTaskScheduler和ThreadPoolTaskExecutor是Spring框架中用于任务调度和线程池管理的类。ThreadPoolTaskScheduler主要用于任务调度，按照时间间隔或Cron表达式执行任务。ThreadPoolTaskExecutor主要用于线程池管理，执行异步任务和多线程任务。
springboot 定时线程池
09-06
在Spring Boot中，你可以使用`@EnableScheduling`注解来启用定时任务功能，并使用`@Scheduled`注解来指定定时任务的执行时间。 首先，在你的Spring Boot应用主类上添加`@EnableScheduling`注解： ```java import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.scheduling.annotation.EnableScheduling; @SpringBootApplication @EnableScheduling public class YourApplication { public static void main(String[] args) { SpringApplication.run(YourApplication.class, args); } } ``` 然后，在你想要执行定时任务的方法上添加`@Scheduled`注解，指定任务的执行时间表达式： ```java import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component public class YourScheduledTask { @Scheduled(cron = "0 0 0 * * ?") // 每天凌晨执行 public void yourTask() { // 执行你的任务逻辑 } } ``` 上述示例中的`@Scheduled(cron = "0 0 0 * * ?")`表示每天凌晨执行任务。你可以根据自己的需求，调整cron表达式来指定不同的执行时间。 此外，Spring Boot还提供了`ThreadPoolTaskScheduler`类来管理定时任务的线程池。你可以在配置类中创建并配置该线程池，然后注入到定时任务中使用。以下是一个示例： ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.SchedulingConfigurer; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import org.springframework.scheduling.config.ScheduledTaskRegistrar; @Configuration @EnableScheduling public class SchedulingConfiguration implements SchedulingConfigurer { @Bean public ThreadPoolTaskScheduler taskScheduler() { ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler(); scheduler.setPoolSize(10); // 设置线程池大小 scheduler.setThreadNamePrefix("YourScheduledTask-"); return scheduler; } @Override public void configureTasks(ScheduledTaskRegistrar taskRegistrar) { taskRegistrar.setTaskScheduler(taskScheduler()); } } ``` 在上述示例中，我们创建了一个名为`taskScheduler`的线程池，并设置了线程池的大小和线程名前缀。然后，在`configureTasks()`方法中将该线程池配置到定时任务注册器中。 这样，你就可以在定时任务方法中使用该线程池来执行并发的任务，确保任务执行的效率和稳定性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值