「任务调度java」任务调度框架

本篇文章给大家谈谈任务调度java，以及任务调度框架对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、为什么使用java 任务调度系统
• 2、java多实例下任务调度问题
• 3、Java Web应用中如何实现任务有效调度
• 4、如何实现自己的任务调度系统？--开源软件诞生18

为什么使用java 任务调度系统

Timer

相信大家都已经非常熟悉 java.util.Timer 了，它是最简单的一种实现任务调度的方法，下面给出一个具体的例子：

清单 1. 使用 Timer 进行任务调度

package com.ibm.scheduler;

import java.util.Timer;

import java.util.TimerTask;

public class TimerTest extends TimerTask {

private String jobName = "";

public TimerTest(String jobName) {

super();

this.jobName = jobName;

}

@Override

public void run() {

System.out.println("execute " + jobName);

}

public static void main(String[] args) {

Timer timer = new Timer();

long delay1 = 1 * 1000;

long period1 = 1000;

// 从现在开始 1 秒钟之后，每隔 1 秒钟执行一次 job1

timer.schedule(new TimerTest("job1"), delay1, period1);

long delay2 = 2 * 1000;

long period2 = 2000;

// 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 job2

timer.schedule(new TimerTest("job2"), delay2, period2);

}

}

Output:

execute job1

execute job1

execute job2

execute job1

execute job1

execute job2

使用 Timer 实现任务调度的核心类是 Timer 和 TimerTask。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。使用者只需要创建一个 TimerTask 的继承类，实现自己的 run 方法，然后将其丢给 Timer 去执行即可。

Timer 的设计核心是一个 TaskList 和一个 TaskThread。Timer 将接收到的任务丢到自己的 TaskList 中，TaskList 按照 Task 的最初执行时间进行排序。TimerThread 在创建 Timer 时会启动成为一个守护线程。这个线程会轮询所有任务，找到一个最近要执行的任务，然后休眠，当到达最近要执行任务的开始时间点，TimerThread 被唤醒并执行该任务。之后 TimerThread 更新最近一个要执行的任务，继续休眠。

Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。

回页首

ScheduledExecutor

鉴于 Timer 的上述缺陷，Java 5 推出了基于线程池设计的 ScheduledExecutor。其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheduedExecutor 才会真正启动一个线程，其余时间 ScheduledExecutor 都是在轮询任务的状态。

清单 2. 使用 ScheduledExecutor 进行任务调度

package com.ibm.scheduler;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ScheduledExecutorTest implements Runnable {

private String jobName = "";

public ScheduledExecutorTest(String jobName) {

super();

this.jobName = jobName;

}

@Override

public void run() {

System.out.println("execute " + jobName);

}

public static void main(String[] args) {

ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

long initialDelay1 = 1;

long period1 = 1;

// 从现在开始1秒钟之后，每隔1秒钟执行一次job1

service.scheduleAtFixedRate(

new ScheduledExecutorTest("job1"), initialDelay1,

period1, TimeUnit.SECONDS);

long initialDelay2 = 1;

long delay2 = 1;

// 从现在开始2秒钟之后，每隔2秒钟执行一次job2

service.scheduleWithFixedDelay(

new ScheduledExecutorTest("job2"), initialDelay2,

delay2, TimeUnit.SECONDS);

}

}

Output:

execute job1

execute job1

execute job2

execute job1

execute job1

execute job2

清单 2 展示了 ScheduledExecutorService 中两种最常用的调度方法 ScheduleAtFixedRate 和 ScheduleWithFixedDelay。ScheduleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；ScheduleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay。由此可见，ScheduleAtFixedRate 是基于固定时间间隔进行任务调度，ScheduleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度。

回页首

用 ScheduledExecutor 和 Calendar 实现复杂任务调度

Timer 和 ScheduledExecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能胜任更加复杂的调度需求。比如，设置每星期二的 16:38:10 执行任务。该功能使用 Timer 和 ScheduledExecutor 都不能直接实现，但我们可以借助 Calendar 间接实现该功能。

清单 3. 使用 ScheduledExcetuor 和 Calendar 进行任务调度

package com.ibm.scheduler;

import java.util.Calendar;

import java.util.Date;

import java.util.TimerTask;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class ScheduledExceutorTest2 extends TimerTask {

private String jobName = "";

public ScheduledExceutorTest2(String jobName) {

super();

this.jobName = jobName;

}

@Override

public void run() {

System.out.println("Date = "+new Date()+", execute " + jobName);

}

/**

* 计算从当前时间currentDate开始，满足条件dayOfWeek, hourOfDay,

* minuteOfHour, secondOfMinite的最近时间

* @return

*/

public Calendar getEarliestDate(Calendar currentDate, int dayOfWeek,

int hourOfDay, int minuteOfHour, int secondOfMinite) {

//计算当前时间的WEEK_OF_YEAR,DAY_OF_WEEK, HOUR_OF_DAY, MINUTE,SECOND等各个字段值

int currentWeekOfYear = currentDate.get(Calendar.WEEK_OF_YEAR);

int currentDayOfWeek = currentDate.get(Calendar.DAY_OF_WEEK);

int currentHour = currentDate.get(Calendar.HOUR_OF_DAY);

int currentMinute = currentDate.get(Calendar.MINUTE);

int currentSecond = currentDate.get(Calendar.SECOND);

//如果输入条件中的dayOfWeek小于当前日期的dayOfWeek,则WEEK_OF_YEAR需要推迟一周

boolean weekLater = false;

if (dayOfWeek currentDayOfWeek) {

weekLater = true;

} else if (dayOfWeek == currentDayOfWeek) {

//当输入条件与当前日期的dayOfWeek相等时，如果输入条件中的

//hourOfDay小于当前日期的

//currentHour，则WEEK_OF_YEAR需要推迟一周

if (hourOfDay currentHour) {

weekLater = true;

} else if (hourOfDay == currentHour) {

//当输入条件与当前日期的dayOfWeek, hourOfDay相等时，

//如果输入条件中的minuteOfHour小于当前日期的

//currentMinute，则WEEK_OF_YEAR需要推迟一周

if (minuteOfHour currentMinute) {

weekLater = true;

} else if (minuteOfHour == currentSecond) {

//当输入条件与当前日期的dayOfWeek, hourOfDay，

//minuteOfHour相等时，如果输入条件中的

//secondOfMinite小于当前日期的currentSecond，

//则WEEK_OF_YEAR需要推迟一周

if (secondOfMinite currentSecond) {

weekLater = true;

}

}

}

}

if (weekLater) {

//设置当前日期中的WEEK_OF_YEAR为当前周推迟一周

currentDate.set(Calendar.WEEK_OF_YEAR, currentWeekOfYear + 1);

}

// 设置当前日期中的DAY_OF_WEEK,HOUR_OF_DAY,MINUTE,SECOND为输入条件中的值。

currentDate.set(Calendar.DAY_OF_WEEK, dayOfWeek);

currentDate.set(Calendar.HOUR_OF_DAY, hourOfDay);

currentDate.set(Calendar.MINUTE, minuteOfHour);

currentDate.set(Calendar.SECOND, secondOfMinite);

return currentDate;

}

public static void main(String[] args) throws Exception {

ScheduledExceutorTest2 test = new ScheduledExceutorTest2("job1");

//获取当前时间

Calendar currentDate = Calendar.getInstance();

long currentDateLong = currentDate.getTime().getTime();

System.out.println("Current Date = " + currentDate.getTime().toString());

//计算满足条件的最近一次执行时间

Calendar earliestDate = test

.getEarliestDate(currentDate, 3, 16, 38, 10);

long earliestDateLong = earliestDate.getTime().getTime();

System.out.println("Earliest Date = "

+ earliestDate.getTime().toString());

//计算从当前时间到最近一次执行时间的时间间隔

long delay = earliestDateLong - currentDateLong;

//计算执行周期为一星期

long period = 7 * 24 * 60 * 60 * 1000;

ScheduledExecutorService service = Executors.newScheduledThreadPool(10);

//从现在开始delay毫秒之后，每隔一星期执行一次job1

service.scheduleAtFixedRate(test, delay, period,

TimeUnit.MILLISECONDS);

}

}

Output:

Current Date = Wed Feb 02 17:32:01 CST 2011

Earliest Date = Tue Feb 8 16:38:10 CST 2011

Date = Tue Feb 8 16:38:10 CST 2011, execute job1

Date = Tue Feb 15 16:38:10 CST 2011, execute job1

java多实例下任务调度问题

有个比较简单的方法，

那就是首先在数据库中加入一个表，用来专门保存任务的。

在应用启动任务时，根据任务ID，去select * from taskID=*** for update

利用 for update的特性实现一个锁机制（如果获取数据成功就执行任务，如果失败就退出）。

在任务完成后再释放。

Java Web应用中如何实现任务有效调度

任务调度是大型J2EEweb应用中常见的工作。开发者希望以指定的间隔时间执行各类操作,并完成一些无需用户输入的任务。java中可有无数方法来做到这一点,但是在web应用中却并没有这方面的统一标准。当许多开发人员参与同一个项目,并且以各自不同的方式来实现任务调度时,就可能产生很大问题。内存和同步问题就是必须首先考虑的两件事。事实上,一些开发者试图调用操作系统层面的任务调度机制,如Unix平台上的cron。这种编程实践也许并不是太坏,但它将直接导致可移植性被抛到九霄云外。

如何实现自己的任务调度系统？--开源软件诞生18

任务调度与ERP难舍难分--第18篇

用日志记录“开源软件”的诞生

任务调度这个词貌似很高大上，其实不难理解。我们知道一个应用它执行任务的方式默认是实时且同步的，而所谓的任务调度就是让任务非实时的或异步的进行。换一个词也可以把它理解成计划任务或定时任务。

要分析任务调度所解决的问题，先要看这个任务的特点以及需要如何执行。首先这类任务一般是系统根据一定的预设逻辑去代替人工完成的一件事。其次这类事无需实时完成或需要在某个特定时间完成，任务启动后只需在后台静默执行，执行完成后有条件的通知用户或用户自主查询执行结果即可。由此可见，以上需求是传统的应用无法做到的，所以就需要任务调度系统去实现它。

从Java技术角度有很多定时任务的实现方式，比如Timer、ScheduledExecutor、Quartz，无论是哪种方式都可以简单的在一个项目中去集成定时任务的功能，而无需单独开发项目。那为什么我们在进行系统设计时，要提出任务调度系统这一思路呢？

那就需要先来分析下信息化系统的特点，首先信息化系统从功能设计的角度是分散的，即一个项目或模块一般只完成一件事的情况下，我们从需要设计很多很多的应用才能满足用户需求。就拿ERP举例，ERP包含计划预算、订单管理、库存管理、财务管理等一系列的模块或系统，而这些系统都是与业务直接关联的，所以哪个系统也离不开计划任务的功能，如果按照上述方式，我们必不可少的要将每个项目中都整合一套完整的计划任务组件才能满足我们的需求。这种做法不仅开发时更加麻烦、同时也带来了维护或扩展复杂度的指数提升，这种设计的风险可想而知。所以独立的任务调度系统就应运而生。

那么我们如何设计这个系统呢？我们来重点关注一下几点。

1、 统一灵活的任务配置

（1）任务实现可配置：任务的具体逻辑可以通过方法或存储过程去实现，然后通过配置方式根据不同参数去自定义不同的任务需求。

（2）定时执行配置：定义好任务的逻辑后我们就需要配置执行逻辑，什么时间执行，是固定时间还是循环，何时开始何时结束，单次执行还是多次执行都需要详细的配置。

（3）线程配置：任务需要同步执行还是异步执行，是守护线程还是非守护线程。异常处理机制等都需要分别配置好。

（4）任务流程配置：有的时候我们不仅仅需要执行一个任务，可能需要执行一系列的任务，而任务的执行又是有先后之分的，这时候我们可以将一个一个配置好的任务串联成一个流程去执行。

2、 便捷的任务启动和反馈

（1）启动任务：所有的任务配置好以后我们就需要启动任务，通过API的方式启动是最优的选择。

（2）反馈机制：对于任务的执行效果要对用户有一个反馈机制，给用户通知、直接回调或反写都是可以选择的方式。

3、 监控任务执行情况和日志追踪

（1）任务监控：任务的执行过程不是一帆风顺的，可能成功，也可能出现执行异常、意外终止、人工终止等多种情况，所以需要根据任务的执行情况显示执行状态，并根据需要，让用户可重启或继续任务。

（2）日志追踪：如果出现重新执行仍然无法成功的情况，那么多数一定是出现了程序异常，所以日志的记录就必不可少，可让维护人员根据日志处理问题并解决问题。

当一个任务调度系统研发完成后，随着使用频率的增加，一定会遇到瓶颈，所以我们就会考虑到部署多个任务调度系统形成分布式，但部署多个系统，就会涉及到注册中心、负载、路由、数据同步等各种问题。本文只是在讨论如何设计任务调度系统的功能，并不涉及分布式调度的思路。在此不展开谈，只是抛砖引玉，有兴趣的朋友可以深入探索。

如果您对我们正在做的开源软件感兴趣，欢迎各种形式的合作，作为贡献者或直接加入我们！让我们一起打造一套开源的信息化解决方案。

任务调度java的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于任务调度框架、任务调度java的信息别忘了在本站进行查找喔。