① java中如何使用任务调度
数据库：使用触发器存储过程 java：
1.JDK自带的 Timer计时器 | TimerTask任务对象 本篇博客详细说下这个方法
2 spring提供的quartz子框架
② 为什么使用java 任务调度系统
Timer
相信大家都已经非常熟悉 java.util.Timer 了，它是最简单的一种实现任务调度的方法，下面给出一个具体的例子：
清单 1. 使用 Timer 进行任务调度
package com.ibm.scheler;
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.schele(new TimerTest("job1"), delay1, period1);
long delay2 = 2 * 1000;
long period2 = 2000;
// 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 job2
timer.schele(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 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。
回页首
ScheledExecutor
鉴于 Timer 的上述缺陷，Java 5 推出了基于线程池设计的 ScheledExecutor。其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。需要注意的是，只有当任务的执行时间到来时，ScheedExecutor 才会真正启动一个线程，其余时间 ScheledExecutor 都是在轮询任务的状态。
清单 2. 使用 ScheledExecutor 进行任务调度
package com.ibm.scheler;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheledExecutorTest implements Runnable {
private String jobName = "";
public ScheledExecutorTest(String jobName) {
super();
this.jobName = jobName;
}
@Override
public void run() {
System.out.println("execute " + jobName);
}
public static void main(String[] args) {
ScheledExecutorService service = Executors.newScheledThreadPool(10);
long initialDelay1 = 1;
long period1 = 1;
// 从现在开始1秒钟之后，每隔1秒钟执行一次job1
service.scheleAtFixedRate(
new ScheledExecutorTest("job1"), initialDelay1,
period1, TimeUnit.SECONDS);
long initialDelay2 = 1;
long delay2 = 1;
// 从现在开始2秒钟之后，每隔2秒钟执行一次job2
service.scheleWithFixedDelay(
new ScheledExecutorTest("job2"), initialDelay2,
delay2, TimeUnit.SECONDS);
}
}
Output:
execute job1
execute job1
execute job2
execute job1
execute job1
execute job2
清单 2 展示了 ScheledExecutorService 中两种最常用的调度方法 ScheleAtFixedRate 和 ScheleWithFixedDelay。ScheleAtFixedRate 每次执行时间为上一次任务开始起向后推一个时间间隔，即每次执行时间为 :initialDelay, initialDelay+period, initialDelay+2*period, …；ScheleWithFixedDelay 每次执行时间为上一次任务结束起向后推一个时间间隔，即每次执行时间为：initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay。由此可见，ScheleAtFixedRate 是基于固定时间间隔进行任务调度，ScheleWithFixedDelay 取决于每次任务执行的时间长短，是基于不固定时间间隔进行任务调度。
回页首
用 ScheledExecutor 和 Calendar 实现复杂任务调度
Timer 和 ScheledExecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能胜任更加复杂的调度需求。比如，设置每星期二的 16:38:10 执行任务。该功能使用 Timer 和 ScheledExecutor 都不能直接实现，但我们可以借助 Calendar 间接实现该功能。
清单 3. 使用 ScheledExcetuor 和 Calendar 进行任务调度
package com.ibm.scheler;
import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheledExceutorTest2 extends TimerTask {
private String jobName = "";
public ScheledExceutorTest2(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 {
ScheledExceutorTest2 test = new ScheledExceutorTest2("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;
ScheledExecutorService service = Executors.newScheledThreadPool(10);
//从现在开始delay毫秒之后，每隔一星期执行一次job1
service.scheleAtFixedRate(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任务调度表达式
最最最笨的办法,只用JAVA写的话,看你自己定义,每1小时将循环执行一次,循环一次最前获取当前时间的HH,也就是小时,判断是否是02,如果是,调用自己程序...最好写个线程来调用，别搞成死循环的离谱,把内存都吃光光了:)
④ java多实例下任务调度问题
有个比较简单的方法，
那就是首先在数据库中加入一个表，用来专门保存任务的。
在应用启动任务时，根据任务ID，去select * from taskID=*** for update
利用 for update的特性实现一个锁机制（如果获取数据成功就执行任务，如果失败就退出）。
在任务完成后再释放。
⑤ JavaWeb应用中如何实现任务有效调度
任务调度是大型J2EEweb应用中常见的工作。开发者希望以指定的间隔时间执行各类操作,并完成一些无需用户输入的任务。java中可有无数方法来做到这一点,但是在web应用中却并没有这方面的统一标准。当许多开发人员参与同一个项目,并且以各自不同的方式来实现任务调度时,就可能产生很大问题。内存和同步问题就是必须首先考虑的两件事。事实上,一些开发者试图调用操作系统层面的任务调度机制,如Unix平台上的cron。这种编程实践也许并不是太坏,但它将直接导致可移植性被抛到九霄云外。
⑥ java任务调度 双机热备
可以通过一个数据库的table去设定达到你想要的结果。每次执行更新这个table的执行时间和执行的服务器，如果监测到一个服务器三分钟都没有执行，就可以启动备用机。
⑦ 几种任务调度的 Java 实现方法与比较
<!-- 要调用的工作类 -->
<bean id="quartzJob" class="com.quartz.QuartzJob"></bean>
<!-- 定义调用对象和调用对象的方法 -->
<bean id="jobtask" class="org.springframework.scheling.quartz.">
<!-- 调用的类 -->
<property name="targetObject">
<ref bean="quartzJob"/>
</property>
<!-- 调用类中的方法 -->
<property name="targetMethod">
<value>work</value>
</property>
</bean>
<!-- 定义触发时间 -->
<bean id="doTime" class="org.springframework.scheling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean="jobtask"/>
</property>
<!-- cron表达式 -->
<property name="cronExpression">
<value>0 0/2 * * * ?</value>
</property>
</bean>
⑧ java如何延时调用web service
延时调用？是指睡眠一定时间在调用ws还是定时调用ws？
如果单纯的希望运行某方法一定时间后在调用ws可以使用Thread.sleep
如果是轮询，每隔一段时间调用ws可以使用以下几种：
1. spring框架整合的Quartz；
2. 使用ScheledThreadPoolExecutor 调度定时任务；
3. 使用Timer 调度定时任务；
你可以先学习学习timer
⑨ Java Web应用中如何实现任务有效调度
任务调度是大型J2EEweb应用中常见的工作。开发者希望以指定的间隔时间执行各类操作,并完成一些无需用户输入的任务。java中可有无数方法来做到这一点,但是在web应用中却并没有这方面的统一标准。当许多开发人员参与同一个项目,并且以各自不同的方式来实现任务调度时,就可能产生很大问题。内存和同步问题就是必须首先考虑的两件事。事实上,一些开发者试图调用操作系统层面的任务调度机制,如Unix平台上的cron。这种编程实践也许并不是太坏,但它将直接导致可移植性被抛到九霄云外。