三种时间调度的方式

最新推荐文章于 2024-07-23 09:25:48 发布
最新推荐文章于 2024-07-23 09:25:48 发布
阅读量4k 收藏 1
点赞数
分类专栏： java

本文转自 http://blog.csdn.net/adjvet/article/details/48790579


1、java.util.Timer, java.util.TimerTask
timer启动一个异步线程执行任务，周期执行任务策略对应方法scheduleAtFixedRate(TimerTask task, long delay, long period)，scheduleAtFixedRate(TimerTask task, Date firstTime, long period)可以指定首次任务时间和周期间隔时间。停止任务执行使用cancel()。
Timer执行任务是单线程的，内部用任务队列来维护待执行任务，任务使用最小堆算法排序（任务下次执行时间距今越小越优先被执行），添加任务时使用锁机制防止并发问题。但是如果自定义的任务处理逻辑包含访问竞争资源，则需要自己进行相关竞争资源的防并发处理。

示例代码如下：

        final Timer timer = new Timer();
        final AtomicInteger taskExecuteCnt = new AtomicInteger();

        TimerTask timerTaskA = new TimerTask() {
            @Override
            public void run() {
                // scheduler work content
                if (taskExecuteCnt.get() >= 10) {
                    timer.cancel();
                }

                System.out.printf("Task A execute,current time:%s\n", new Date());
                taskExecuteCnt.incrementAndGet();
            }
        };

        TimerTask timerTaskB = new TimerTask() {
            @Override
            public void run() {
                // scheduler work content
                if (taskExecuteCnt.get() >= 10) {
                    timer.cancel();
                }

                System.out.printf("Task B execute,current time:%s\n", new Date());
                taskExecuteCnt.incrementAndGet();
            }
        };

        timer.scheduleAtFixedRate(timerTaskA, 0, 500);
        timer.scheduleAtFixedRate(timerTaskB, 0, 500);

执行后结果：
Task A execute,current time:Mon Sep 28 14:08:21 CST 2015
Task B execute,current time:Mon Sep 28 14:08:21 CST 2015
Task B execute,current time:Mon Sep 28 14:08:22 CST 2015
Task A execute,current time:Mon Sep 28 14:08:22 CST 2015
Task A execute,current time:Mon Sep 28 14:08:22 CST 2015
Task B execute,current time:Mon Sep 28 14:08:22 CST 2015
Task B execute,current time:Mon Sep 28 14:08:23 CST 2015
Task A execute,current time:Mon Sep 28 14:08:23 CST 2015
Task A execute,current time:Mon Sep 28 14:08:23 CST 2015
Task B execute,current time:Mon Sep 28 14:08:23 CST 2015
Task B execute,current time:Mon Sep 28 14:08:24 CST 2015

如上，执行顺序为A,B,B,A,A,B,B,A,A,B,B。出现这种同一个任务连续执行是因为Timer内部用队列维护待处理任务，队列排序算法为最小二叉堆（任务下次执行时间距今越小越优先被执行），上述A,B任务的起始执行时间都为0，周期间隔都为500ms。那么待执行任务队列堆如下
       A
   B    A1
B1

A执行完后，经过重排堆变为

        B
   B1   A1

B执行完后，经过重排堆变为

        B1
             A1
所以就会出现堆重排序导致优先级相等的任务执行顺序不固定，如果需要多个任务以特定顺序执行，可通过指定任务首次执行延迟时间来实现，
        timer.scheduleAtFixedRate(timerTaskA, 0, 500);
        timer.scheduleAtFixedRate(timerTaskB, 1, 500);
如上指定，则同一个周期内A任务永远先与B任务执行。

另外，如果某个任务执行时间过长，导致下次触发任务执行时队列中多个任务下次执行时间已到，则会发生多个任务连续执行。如果任务执行时间对执行结果有影响，则合理指定任务周期,单任务处理的数据量，或者使用异步处理机制来确保任务执行正确性（任务触发时只记录一条任务流水，流水记录中包括任务触发时的状态，后续通过额外的恢复任务处理任务流水，异步处理逻辑还可以保证在系统故障时不会丢失队列中待处理的任务）。


2、java.util.concurrent .ScheduledExecutorService

使用java.util.concurrent .ScheduledExecutorService执行任务时，ScheduledExecutorService内部使用线程池执行任务，可以指定执行任务的线程池大小。并发任务较多时可以配置合适的线程池大小提高任务执行效率。


示例代码如下：
        final ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
        final AtomicInteger taskExecuteCnt = new AtomicInteger();

        Runnable runnableA = new Runnable() {
            @Override
            public void run() {
                // scheduler work content
                if (taskExecuteCnt.get() >= 10) {
                    scheduledExecutorService.shutdownNow();
                }

                System.out.printf("Task A execute,current time:%s\n", new Date());
                taskExecuteCnt.incrementAndGet();
            }
        };

        Runnable runnableB = new Runnable() {
            @Override
            public void run() {
                // scheduler work content
                if (taskExecuteCnt.get() >= 10) {
                    scheduledExecutorService.shutdownNow();
                }

                System.out.printf("Task B execute,current time:%s\n", new Date());
                taskExecuteCnt.incrementAndGet();
            }
        };

        scheduledExecutorService.scheduleWithFixedDelay(runnableA, 0, 500, TimeUnit.MILLISECONDS);
        scheduledExecutorService.scheduleWithFixedDelay(runnableB, 0, 500,TimeUnit.MILLISECONDS);

这里使用的调度方法是scheduleWithFixedDelay，和scheduleWithFixedRate的区别是：

scheduleWithFixedDelay任务的下次执行时间是根据前次执行结束时间和时间间隔计算得到。
scheduleWithFixedRate任务的下次执行时间是根据前次执行开始时间加时间间隔得到。

使用两个方法可能带来的影响是，如果任务执行时间过长，scheduleWithFixedDelay计算得到的待执行任务个数小于scheduleWithFixedRate计算得到的任务个数。


3、Quartz
Quzrtz支持用cron表达式来定义灵活多变的任务触发时间，例如表达式(0/1 * * * * ?)表示每秒触发任务执行。

spring quarz任务调度示例代码如下：

配置需要的beans，配置文件为quartz.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
    default-autowire="byName">

    <bean id="cronTaskA" class="com.test.CronTask">
        <property name="jobContent" value="Task A execute" />
    </bean>
    <bean id="cronTaskB" class="com.test.CronTask">
        <property name="jobContent" value="Task B execute" />
    </bean>

    <bean id="jobDetailA"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="cronTaskA" />
        <property name="targetMethod" value="run" />
        <property name="concurrent" value="false" />
    </bean>

    <bean id="jobDetailB"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="cronTaskB" />
        <property name="targetMethod" value="run" />
        <property name="concurrent" value="false" />
    </bean>

    <bean id="cronTriggerA" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <!-- jobDetail -->
        <property name="jobDetail" ref="jobDetailA" />

        <!-- execute per second -->
        <property name="cronExpression" value="0/1 * * * * ?" />
    </bean>

    <bean id="cronTriggerB" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <!-- jobDetail -->
        <property name="jobDetail" ref="jobDetailB" />

        <!-- execute per second -->
        <property name="cronExpression" value="0/1 * * * * ?" />
    </bean>

    <bean id="schedulerFactory"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="cronTriggerA" />
                <ref bean="cronTriggerB" />
            </list>
        </property>
    </bean>
</beans>

自定义任务类实现：
public class CronTask {

    /** logger */
    private static final Logger logger = LoggerFactory.getLogger(CronTask.class);

    /** job content */
    private String              jobContent;

    /**
     * task content
     */
    public void run() {
        if (logger.isInfoEnabled()) {
            logger.info(jobContent);
        }
    }

    /**
     * Setter method for property <tt>jobContent</tt>.
     * 
     * @param jobContent value to be assigned to property jobContent
     */
    public void setJobContent(String jobContent) {
        this.jobContent = jobContent;
    }

}


任务调度测试代码：

        try {
            String xmlPath = System.getProperty("user.dir") +File.separator + "quartz.xml";

            System.out.println(FileUtils.readLines(new File(xmlPath)));

            new FileSystemXmlApplicationContext(xmlPath);

            logger.info("Run QuartzJob");

        } catch (Exception e) {
            logger.error("Exception occurred during quartz job execution.", e);
        }



金色年华III
关注
专栏目录
java周期调度几种实现
adjvet的专栏
09-28 7760
写代码的时候有些任务需要做周期处理，例如每天9点解析文件并落地到数据库。这时候就需要选择合适的任务调度策略。以下是java里常用的几个任务调度方法： 1、java.util.Timer, java.util.TimerTask timer启动一个异步线程执行任务，周期执行任务策略对应方法scheduleAtFixedRate(TimerTask task, long delay, long
java实现周期任务_java定时任务的实现方式
weixin_32613887的博客
02-19 2802
本文列举常见的java定时任务实现方式，并做一定比较。1. 循环内部sleep实现周期执行创建一个thread，run() while循环里sleep()来实现周期性执行; 简单粗暴，作为一个初学者很容易想到。public class Task1 {public static void main(String[] args) {// run in a secondfinal long timeI...
时间调度
rockjank的博客
09-09 531
package class1; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask;  class MyTask extends TimerTask { public void run() { SimpleDateFor
java 周期任务_如何在Java中安排周期性任务？
weixin_42349261的博客
02-16 601
慕村225694试试这条路->首先，创建一个运行任务的类TimeTask，如下所示：publicclassCustomTaskextendsTimerTask{publicCustomTask(){//Constructor}publicvoidrun(){try{//Yourtaskprocess...
时间调度器
JDIT的博客
05-04 568
回到首页☞ 1、定位 了解 2、概述 定时任务几乎很多系统或者语言都有这个功能，也是常规功能，linux的 crontab，java quaze job，js 的定时器等等。 mysql也有自己的定时器event，目前实际项目没用过，因为我们往往习惯用放到mybatis实现，为了便于维护。 MySQL事件调度器（Event Scheduler），可以在某一个时间点执行一个SQL语句或一个语句块（B...
YARN三种调度方式
BackToMe的博客
09-06 7133
FIFO Capacity Fair
linux内核的三种调度方法
07-21
SCHED_OTHER（分时调度策略）是一种传统的时间片轮转调度方式，它为不同优先级的进程分配不同长度的时间片，并通过时间片轮转来实现对CPU资源的公平分配。分时调度中，每个进程被分配一个nice值，该值决定了进程获得...
spring的三种任务调度实现方式lib
01-19
在实际应用中，选择哪种任务调度方式取决于具体需求。如果任务调度需求简单且不需要复杂的规则，Spring内置的任务调度器就足够了。当需要更复杂的时间表和调度策略时，Quartz是一个好选择。而当涉及到批量处理大量...
YARN的三种调度器
weixin_49539546的博客
03-26 3947
理想情况下，我们应用对yarn资源的请求应该立刻被满足，但是实际上，资源有限。特别是很忙的集群。 调度本身就是一大难题，很难找到完美的解决方案，所以yarn提供了三种调度器 1.FIFO Scheduler FIFO = first in first out 先进先出 （队列） 这种调度把应用提交按顺序排成一个队列，先进先出的队列，在进行资源分配的时候，先给队列中最头部的应用分配资源，等到应用满足了，再给下一个分配，以此类推。 问题：大的应用可能会占用所有的资源，造成阻塞，不适合集群 2
wifi TDD 时间同步及分时调度方案
06-23
分时调度的实现方式是通过在 MAC 层中添加一个时隙调度模块，该模块由缓冲队列、定时器模块和链路调度器三部分组成。 其中缓冲队列用于接收并缓存从 CSMA/CA 机制出来的报文，硬件定时器会定时触发时钟中断到软件...
java多线程调度_Java多线程：生命周期，实现与调度
weixin_42101720的博客
02-15 258
前面几篇文章为Java多线程做足了铺垫，这篇终于到了正题，一起学习一下Java多线程的基础知识。1. Java线程生命周期下图表述了Java线程的几个基本状态：New新建状态：线程创建后即进入。Runnable就绪状态：调用线程的start方法后，线程不会立刻运行，而是进入就绪状态，等待CPU调度。Running运行状态： CPU开始调度处于就绪状态的线程后，线程进入运行状态。换言之，就绪状态是运...
50、实时调度的实现方法
TakahashiRyosuke的博客
06-02 647
文章目录静态表驱动调度法（Static table-driven）静态优先级调度法（Static priority-driven preemptive）动态计划调度法（Dynamic planning-based）动态最大努力调度法（Dynamic best effort） 静态表驱动调度法（Static table-driven） 根据一张静态的表格来决定下一个执行的任务； 用于调度周期性实时任务； 按照任务周期到达的时间、执行时间、完成截至时间以及任务的优先级，制定调度表，调度实时任务。 最早截止时间
Java如何实现周期性操作？
jardownload的博客
08-12 439
可以通过继承TimerTask虚类并方法来实现周期性操作，下面的例子实现了一个周期性操作： import java.util.TimerTask; public class HeartBeatTask extends TimerTask{ private int timerInterval; public HeartBeatTask(int timeInterval){ this.timerInt...
系统调度时间
shenhuxi_yu的专栏
12-02 735
WDT一般都是系统中优先级最低的线程 但是系统的调度会保证低优先级的任务也会被执行到，线程要主动休眠放弃cpu 可以利用这一点判断WDT线程被调度两次之间的间隔来判断当前系统的调度情况
处理机调度算法（时间调度）
半亩天堂
12-14 3199
南昌航空大学实验报告 课程名称:  操作系统              实验名称:   处理机调度 班级:110462          姓名:黄 绍 宇    学号:  11046208 一 实验目的: 编写程序以下面三种方式之一模拟处理机调度。要求掌握几种处理机调度算法的基本思想和特点，理解并发与并行的区别，学会设计处理调度算法 二 实验内容: 时间片轮转算法: 时间片轮转调
Java 多线程二：调度和分类和生命周期
qq_48010634的博客
12-06 76
Java 多线程二：调度和分类和生命周期
java 时间调度,Java定时调度机制 - Timer
weixin_29195615的博客
03-20 416
简介在实现定时调度功能的时候，我们往往会借助于第三方类库来完成，比如：quartz、Spring Schedule等等。JDK从1.3版本开始，就提供了基于Timer的定时调度功能。在Timer中，任务的执行是串行的。这种特性在保证了线程安全的情况下，往往带来了一些严重的副作用，比如任务间相互影响、任务执行效率低下等问题。为了解决Timer的这些问题，JDK从1.5版本开始，提供了基于Schedu...
【时间调度器&线程】学习笔记
Your_name666的博客
06-11 200
事件调度器 事件调度器：顾名思义，主要作用是调度事件。其实对我而言，这个更像是一个定时器。这里不给出过多的解释(内容本身不复杂，暂时没找到官方的解释，担心误人子弟)。直接上代码。展示结果。 函数 sched = scheduler() # 实例化调度器 sched.enter() # 加入事件 sched.run() # 运行调度器 代码 # -*-coding: utf-8 -*- import time def GetTime(): time_stamp = time.time()
Java中的调度任务
最新发布
weixin_46372265的博客
07-23 654
JUnit是Java最流行的测试框架之一。最新的版本是JUnit 5，它引入了许多新特性和改进，使测试更加方便和高效。@Test：标记一个方法为测试方法。：在每个测试方法执行之前运行，用于初始化测试环境。@AfterEach：在每个测试方法执行之后运行，用于清理测试环境。@BeforeAll：在所有测试方法执行之前运行一次，用于全局初始化。@AfterAll：在所有测试方法执行之后运行一次，用于全局清理。通过本文的介绍，我们深入了解了Java中调度任务的多种实现方式，从简单的到功能强大的。
抢占式优先级与时间片轮转进程调度算法实现
通过这种方式，学生可以深入理解这两种调度算法的工作原理，观察它们在模拟环境下如何影响进程的执行顺序和系统性能。指导教师的意见和评分对学生的理解和实践能力进行了评估，有助于学生进一步改进和完善设计。 可...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值