Timer计时器有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。但是，Timer存在一些缺陷，因此你应该考虑使用ScheduledThreadPoolExecutor作为代替品,Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支持相对时间。
Timer的另一个问题在于，如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以TimerTask抛出的未检查的异常会终止timer 线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被安排但尚未执行的TimerTask永远不会再执行了，新的任务也不能被调度了。
例子：
packagecom.concurrent.basic;
importjava.util.Timer;
import java.util.TimerTask;
public class TimerTest {
private Timer timer = new Timer();
// 启动计时器
public void lanuchTimer() {
timer.schedule(new TimerTask() {
public void run() {
throw new RuntimeException();
}
}, 1000 * 3, 500);
}
// 向计时器添加一个任务
public void addOneTask() {
timer.schedule(new TimerTask() {
public void run() {
System.out.println("hello world");
}
}, 1000 * 1, 1000 * 5);
}
public static void main(String[] args) throws Exception {
TimerTest test = new TimerTest();
https://www.doczj.com/doc/1813516196.html,nuchTimer();
Thread.sleep(1000 * 5);// 5秒钟之后添加一个新任务
test.addOneTask();
}
}
执行结果：
你可能希望第二个没有异常的线程会一直运行下去，然而实际情况如程序所示5秒钟后就中止了，还伴随着一个异常，异常的消息是"Timer already cancelled"。
ScheduledThreadPoolExector妥善地处理了这个异常的任务，所以说在java5.0或更高的JDK中，几乎没有理由再使用Timer了。
java5.0后提供
public interface ScheduledExecutorService
extends ExecutorService
一个ExecutorService，可安排在给定的延迟后运行或定期执行的命令。
schedule方法使用各种延迟创建任务，并返回一个可用于取消或检查执行的任务对象。scheduleAtFixedRate和scheduleWithFixedDelay方法创建并执行某些在取消前一直定期运行的任务。
而且不受时钟限制。
例子：
package com.concurrent.basic;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ScheduledExecutorTest {
//线程池能按时间计划来执行任务，允许用户设定计划执行任务的时间，int类型的参数是设定
//线程池中线程的最小数目。当任务较多时，线程池可能会自动创建更多的工作线程来执行任务
public ScheduledExecutorService scheduExec =
Executors.newScheduledThreadPool(1);
//启动计时器
public void lanuchTimer(){
Runnable task = new Runnable() {
public void run() {
throw new RuntimeException();
}
};
scheduExec.scheduleWithFixedDelay(task, 1000*5, 1000*10,
https://www.doczj.com/doc/1813516196.html,LISECONDS);
}
//添加新任务
public void addOneTask(){
Runnable task = new Runnable() {
public void run() {
System.out.println("welcome to china");
}
};
scheduExec.scheduleWithFixedDelay(task, 1000*1, 1000,
https://www.doczj.com/doc/1813516196.html,LISECONDS);
}
public static void main(String[] args) throws Exception { ScheduledExecutorTest test = new ScheduledExecutorTest();
https://www.doczj.com/doc/1813516196.html,nuchTimer();
Thread.sleep(1000*5);//5秒钟之后添加新任务
test.addOneTask();
}
}
但是ScheduledThreadPoolExecutor也有不利的地方，就是只能按相对的时间的，而不能设置具体某个时刻之后执行，如每天晚上12点定时执行任务之类的要求使用Timer更合适，如果是周期性的重复工作可以考虑使用ScheduledThreadPoolExecutor。
Java定时任务ScheduledThreadPoolExecutor
2012-08-05 13:15:00
以前定时任务一直用Timer这个类，后来发现ScheduledThreadPoolExecutor功能更强大，我们先看个简单的示例，然后再看看API中的描述：
这个定时任务是我的项目中，每隔5分钟去检查设备的在线状态的。[java]
public class CheckDeviceStateExcuter {
private static final Log log =
LogFactory.getLog(CheckDeviceStateExcuter.class);
private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
private static DeviceDaodeviceDao = new DeviceDaoImpl();
private static List
ArrayList
// invoke DLL method to get the details of device
static JoymindCommDLLLib instance =
JoymindCommDLLLib.INSTANCE;
// check states
public static void checkStart() {
final Runnable checker = new Runnable() {
public void run() {
System.out.println("check");
devices = deviceDao.queryDevices();
for(DeviceDTO device : devices){
String ip = device.getIp();
String id = "auto_refresh_" + ip;
String iniPath = XmlOperationTool.PLAYLIST_TEMPFILE_FOLDER + id
+ ".ini";
int flag = instance.GetSysInfo(ip, iniPath);
if(flag == 1){
// get ini file
SystemInfoDTO info = null;
try {
info = FileOperationTool.parseIni(iniPath);
device.setMacAdd(info.getMacAddress()); device.setIp(info.getIp());
device.setGateway(info.getGateway()); device.setOnlineState("在线");
device.setBootTime(info.getBootTime()); device.setDeviceVersion(info.getVersion()); device.setAvailableSpace(info.getFreedisk());
device.setpNo(info.getpNo());
device.setWidth(info.getWidth());
device.setHeight(info.getHeight());
device.setStorage(info.getStorage()); device.setTime(info.getTime());
device.setPrgTotal(info.getPrgTotal()); device.setPrgIndex(info.getPrgIndex()); device.setStatusNo(info.getStatus());
if (info.getStorage().equals("1")) {
device.setStorageName("FLASH存储");
}
if (info.getStorage().equals("2")) {
device.setStorageName("RAM存储");
}
if (info.getStorage().equals("3")) {
device.setStorageName("SD卡存储");
}
device.setCurrentPlaylist("");
device.setCurrentTemplate("");
device.setLastCommunicateTime(""); device.setCurrentTransferFileName(""); device.setCurrentTransferSpeed("");
device.setCurrentPercentage("");
device.setVolume("");
device.setAutoBootTime("");
device.setAutoShutdownTime("");
device.setPlayingVideo("");
device.setProgramUpdateTime("");
device.setProgramUpdateState("");
} catch (IOException e1) {
if (log.isErrorEnabled()) {
log.error(e1.getMessage());
}
e1.printStackTrace();
}
booleanaddFlag = deviceDao.updateDevice(device);
if (addFlag) {
if (log.isDebugEnabled()) {
log.debug("auto update device "+device.getName()+" successfully"); }
} else {
if (log.isErrorEnabled()) {
log.error("auto update device failed !!!");
}
}
}else{
deviceDao.updateDevice(ip, "离线");
if (log.isDebugEnabled()) {
log.debug("auto update device "+device.getName()+" statue offline"); }
}
}
}
};
// 此处的checker是一个线程，1表示启动延迟1个单位开始执行这个线程，然后每隔5分钟执行一次，单位是分钟
final ScheduledFuturecheckerHandle =
scheduler.scheduleAtFixedRate(checker, 1, 5, TimeUnit.MINUTES);
// 这里注释的地方是取消这个定时任务的，是在3600天后停止，因为我这里是检查设备的，所以除非当程序退出才自动停止这个定时任务
/*
scheduler.schedule(new Runnable() {
public void run() {
checkerHandle.cancel(true);
}
}, 60 * 60, TimeUnit.DAYS);
*/
}
/**
* @paramargs
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
再看看API的具体信息，总之这是个非常实用的类
public class ScheduledThreadPoolExecutor
extends ThreadPoolExecutor
implements ScheduledExecutorService
ThreadPoolExecutor，它可另行安排在给定的延迟后运行命令，或者定期执行命令。需要多个辅助线程时，或者要求ThreadPoolExecutor具有额外的灵活性或功能时，此类要优于Timer。
一旦启用已延迟的任务就执行它，但是有关何时启用，启用后何时执行则没有任何实时保证。按照提交的先进先出(FIFO) 顺序来启用那些被安排在同一执行时间的任务。
虽然此类继承自ThreadPoolExecutor，但是几个继承的调整方法对此类并无作用。特别是，因为它作为一个使用corePoolSize线程和一个无界队列的固定大小的池，所以调整maximumPoolSize没有什么效果。
扩展注意事项：此类重写AbstractExecutorService的submit 方法，以生成内部对象控制每个任务的延迟和调度。若要保留功能性，子类中任何进一步重写的这些方法都必须调用超类版本，超类版本有效地禁用附加任务的定制。但是，此类提供替代受保护的扩展方法decorateTask（为
Runnable 和Callable 各提供一种版本），可定制用于通过execute、submit、schedule、scheduleAtFixedRate和scheduleWithFixedDelay
进入的执行命令的具体任务类型。默认情况下，ScheduledThreadPoolExecutor使用一个扩展FutureTask的任务类型。但是，可以使用下列形式的子类修改或替换该类型。
public class CustomScheduledExecutor extends ScheduledThreadPoolExecutor {
static class CustomTask
protected
Runnable r, RunnableScheduledFuture
return new CustomTask
}
protected
Callable
return new CustomTask
}
// ... add constructors, etc.
}
Spring提供的三种定时任务机制及其比较 定时任务的需求在众多应用系统中广泛存在，在Spring中，我们可以使用三种不同的定时机制，下面一一描述并加以比较 1. 基于Quartz的定时机制
下面详细解释这个类图中涉及的关键类及其使用场景 1.1. SchedulerFactoryBean 这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定义在这个类中的所有trigger Spring配置范例： [xhtml]view plaincopy 1.
Spring配置范例： [xhtml]view plaincopy 1.
Timer计时器有管理任务延迟执行("如1000ms后执行任务")以及周期性执行("如每500ms执行一次该任务")。但是，Timer存在一些缺陷，因此你应该考虑使用ScheduledThreadPoolExecutor作为代替品,Timer对调度的支持是基于绝对时间,而不是相对时间的，由此任务对系统时钟的改变是敏感的;ScheduledThreadExecutor只支持相对时间。 Timer的另一个问题在于，如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以TimerTask抛出的未检查的异常会终止timer 线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被安排但尚未执行的TimerTask永远不会再执行了，新的任务也不能被调度了。 例子： packagecom.concurrent.basic; importjava.util.Timer; import java.util.TimerTask; public class TimerTest { private Timer timer = new Timer(); // 启动计时器 public void lanuchTimer() { timer.schedule(new TimerTask() { public void run() { throw new RuntimeException(); } }, 1000 * 3, 500); } // 向计时器添加一个任务 public void addOneTask() { timer.schedule(new TimerTask() { public void run() { System.out.println("hello world"); } }, 1000 * 1, 1000 * 5); }
Spring+Quartz定时器例子如下： 1. javabean类 在Test.QuartzJob中 1.package Test; 2. 3.public class QuartzJob { 4.public void work() 5. { 6. System.out.println("Quartz的任务调度！！！"); 7. } 8. } 1. 2.
Java每天定时执行任务 java定时任务，每天定时执行任务。以下是这个例子的全部代码。 public class TimerManager { //时间间隔 private static final long PERIOD_DAY = 24 * 60 * 60 * 1000; public TimerManager() { Calendar calendar = Calendar.getInstance(); /*** 定制每日2:00执行方法***/ calendar.set(Calendar.HOUR_OF_DAY, 2); calendar.set(Calendar.MINUTE, 0); calendar.set(Calendar.SECOND, 0); Date date=calendar.getTime(); //第一次执行定时任务的时间 //如果第一次执行定时任务的时间小于当前的时间 //此时要在第一次执行定时任务的时间加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。 if (date.before(new Date())) { date = this.addDay(date, 1); } Timer timer = new Timer(); NFDFlightDataTimerT ask task = new NFDFlightDataTimerTask(); //安排指定的任务在指定的时间开始进行重复的固定延迟执行。 timer.schedule(task,date,PERIOD_DAY); } // 增加或减少天数 public Date addDay(Date date, int num) { Calendar startDT = Calendar.getInstance(); startDT.setTime(date); startDT.add(Calendar.DAY_OF_MONTH, num); return startDT.getTime(); }
Spring+Quartz实现定时任务的配置方法 第一步：.导入相关的jar包 (1)spring.jar (2)quartz-1.6.0.jar (3)相关包 commons-collections-3.2.jar ; commons-logging-1.1.1.jar; log4j-1.2.16.jar 第二步：创建一个类来定义工作 定义Quartz工作的第一步是创建一个类来定义工作。要做到这一点，你需要从Spring 的QuartzJobBean中派生子类。 第三步：配置JobDetail
值得注意的是，在这里你并没有直接声明一个TopTenTask Bean，而是声明了一个JobDetailBean。这是使用Quartz时的一个特点。 JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。 使用Quartz的JobDetail中的另一个特别之处是TopTenTask的timeout属性是间接设置的。JobDetail的jobDataAsMap属性接受一个java.util.Map，其中包含了需要设置给jobClass的各种属性。 在这里，这个map包含了一个键值为timeout。当JobDetailBean实例化时，它会将5注入到EmailReportJob的timeout属性中。 第四步：配置Trigger 工作已经被定义好了，接下来你需要调度这个工作。 Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。 Spring提供了两个触发器，SimpleTriggerBean和CronTriggerBean。 SimpleTriggerBean与ScheduledTimerTask类似。你可以用它来指定一个工作应该以怎样的频度运行，以及（可选地）在第一次运行工作之前应该等待多久。 例如，要调度报表工作每24小时运行一次，第一次在1小时之后开始运行，可以按照以下方式进行声明：
Java定时任务的实现 一、通过java本身提供的接口实现 关键词：监听器（Listener）和定时器（Timer）任务（Task）。 方式： 首先：建立一个监听器 MyListener import java.util.Timer; import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class MyListener implements ServletContextListener { private Timer timer = null; public void contextInitialized(ServletContextEvent event) { timer = new Timer(true); //设置任务计划，启动和间隔时间 timer.schedule(new MyTask(), 0, 86400000); } public void contextDestroyed(ServletContextEvent event) { timer.cancel(); } } 监听器web.xml配置
登录 https://localhost:8443 注意是https，采用的是jetty ssl链接。输入账号密码azkaban/azkanban（如果你之前没有更改的话） 首页 首页有四个菜单 ?projects：最重要的部分，创建一个工程，所有flows将在工程中运行。 ?scheduling:显示定时任务 ?executing:显示当前运行的任务 ?history:显示历史运行任务 主要介绍projects部分 首先创建一个工程，填写名称和描述，比如o2olog。 o2olog工程 Flows：工作流程，有多个job组成 Permissions:权限管理 Project Logs:工程日志 创建工程： 创建之前我们先了解下之间的关系，一个工程包含一个或多个flows，一个flow包含多个job。job是你想在azkaban中运行的一个进程，可以是简单的linux命令，可是java程序，也可以是复杂的shell脚本，当
然，如果你安装相关插件，也可以运行插件。一个job可以依赖于另一个job，这种多个job和它们的依赖组成的图表叫做flow。 job创建 创建job很简单，只要创建一个以.job结尾的文本文件就行了,例如我们创建一个工作，用来将日志数据导入hive中（关于大数据方面的东西，不在重复，可以理解为，将日志所需数据导入的mysql中），我们创建o2o_2_hive.job type=command command=echo "data 2 hive" 一个简单的job就创建好了，解释下，type的command，告诉azkaban用unix原生命令去运行，比如原生命令或者shell脚本，当然也有其他类型，后面说。 一个工程不可能只有一个job，我们现在创建多个依赖job，这也是采用azkaban的首要目的。 flows创建 我们说过多个jobs和它们的依赖组成flow。怎么创建依赖，只要指定dependencies参数就行了。比如导入hive前，需要进行数据清洗，数据清洗前需要上传，上传之前需要从ftp获取日志。 定义5个job： 1.o2o_2_hive.job：将清洗完的数据入hive库 2.o2o_clean_data.job：调用mr清洗hdfs数据 3.o2o_up_2_hdfs.job：将文件上传至hdfs 4.o2o_get_file_ftp1.job：从ftp1获取日志 5.o2o_get_file_fip2.job：从ftp2获取日志 依赖关系： 3依赖4和5，2依赖3，1依赖2，4和5没有依赖关系。 o2o_2_hive.job type=command # 执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程command=sh /job/o2o_2_hive.sh dependencies=o2o_clean_data o2o_clean_data.job type=command # 执行sh脚本，建议这样做，后期只需维护脚本就行了，azkaban定义工作流程command=sh /job/o2o_clean_data.sh dependencies=o2o_up_2_hdfs o2o_up_2_hdfs.job
util包中的定时器学习相对比较简单，学习java定时器主要要熟悉两个类，Timer类和TimerTask类。 定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定指定的任务task在指定的延迟delay后执行。定时器任务类TimerTask 是抽象类，继承并重写其run()方法，可实现具体任务。 schedule(TimerTask task, Date time)设定指定任务task在指定时间time执行。 cancel()方法结束这个定时器。 schedule(TimerTask task, long delay, long period)方法设定指定任务task在指定延迟delay后进行固定延迟peroid的执行。 scheduleAtFixedRate(TimerTask task, long delay, long period)方法设定指定任务task在指定延迟delay后进行固定频率peroid的执行。 要实现一个定时任务，运用java中的Timer和TimerTask类可以非常容易实现实时调用处理函数。这两个类使用起来非常方便，可以完成我们对定时器的绝大多数需要。 package com.csdn.heima; import java.io.IOException; import java.util.Scanner; import java.util.Timer; public class TimerTest { public static void main(String[] args){ Timer timer = new Timer(); timer.schedule(new MyTask(), 1000, 3000);//在1秒后执行此任务,以后每隔1秒执行这个MyTask任务. while(true){ Scanner scan = new Scanner(System.in); String str = scan.nextLine(); if(str.equals("ok")){ timer.cancel();// 终止此计时器，丢弃所有当前已安排的任务。 } } } static class MyTask extends java.util.TimerTask{
java定时任务Timer 关于定时任务，似乎跟时间操作的联系并不是很大，但是前面既然提到了定时任务，索性在这里一起解决了。设置定时任务很简单，用Timer类就搞定了。 一、延时执行首先，我们定义一个类，给它取个名字叫TimeTask，我们的定时任务，就在这个类的main函数里执行。代码如下： 解释一下上面的代码。上面的代码实现了这样一个功能，当TimeTask程序启动以后，过一分钟后执行某项任务。很简单吧：先new一个Timer对象，然后调用它的schedule方法，这个方法有四个重载的方法，这里我们用其中一个， 首先，第一个参数第一个参数就是我们要执行的任务。这是一个TimerTask对象，确切点说是一个实现TimerTask的类的对象，因为TimerTask是个抽象类。上面的代码里面，Task就是我们自己定义的实现了TimerTask的类，因为是在同一个包里面，所以没有显性的import进来。Task类的代码如下 我们的Task必须实现TimerTask的方法run，要执行的任务就在这个run方法里面，这里，我们只让它往控制台打一行字。第二个参数第二个参数是一个long型的值。这是延迟的时间，就是从程序开始以后，再过多少时间来执行定时任务。这个long型的值是毫秒数，所以前面我们的程序里面，过一分钟后执行用的参数值就是60 * 1000。 二、循环执行设置定时任务的时候，往往我们需要重复的执行这样任务，每隔一段时间执行一次，而上面的方法是只执行一次的，这样就用到了schedule方法的是另一个重载函数
前两个参数就不用说什么了，最后一个参数就是间隔的时间，又是个long型的毫秒数（看来java里涉及到时间的，跟这个long是脱不了干系了），比如我们希望上面的任务从第一次执行后，每个一分钟执行一次，第三个参数值赋60 * 1000就ok了。 三、指定执行时间既然号称是定时任务，我们肯定希望由我们来指定任务指定的时间，显然上面的方法就不中用了，因为我们不知道程序什么时间开始运行，就没办法确定需要延时多少。没关系，schedule 四个重载的方法还没用完呢。用下面这个就OK了： 比如，我们希望定时任务2006年7月2日0时0分执行，只要给第二个参数传一个时间设置为2006年7月2日0时0分的Date对象就可以了。有一种情况是，可能我们的程序启动的时候，已经是2006 年7月3日了，这样的话，程序一启动，定时任务就开始执行了。schedule最后一个重载的方法是 没必要说什么了吧:) 四、j2ee中的定时任务在实际的项目中，往往定时任务需要对web工程中的资源进行操作，这样一来，用上面的单个程序的方式可能就有点力不从心了，因为很多web工程的资源它操作不到。解决的办法是，使用Servlet，把执行定时任务的那些代码放到Servlet的init()函数里就可以了，这个easy，就没有必要再写示例代码了吧。
java类Timer和TimerTask的使用这两个类使用起来非常方便，可以完成我们对定时器的绝大多数需求 Timer类是用来执行任务的类，它接受一个TimerTask做参数 Timer有两种执行任务的模式,最常用的是schedule,它可以以两种方式执行任务:1:在某个时间(Data)，2:在某个固定的时间之后(int delay).这两种方式都可以指定任务执行的频率.看个简单的例子: import java.io.IOException; import java.util.Timer; public class TimerTest { public static void main(String[] args){ Timer timer = new Timer(); timer.schedule(new MyTask(), 1000, 2000);//在1秒后执行此任务,每次间隔2秒,如果传递一个Data参数,就可以在某个固定的时间执行这个任务. while(true){//这个是用来停止此任务的,否则就一直循环执行此任务了 try { int ch = System.in.read(); if(ch-'c'==0){ timer.cancel();//使用这个方法退出任务 } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } static class MyTask extends java.util.TimerTask{ @Override public void run() { // TODO Auto-generated method stub
定时器 1、首先在导入Spring所有包的前提下还要导入一个定时器包：quartz-1.6.2.jar，然后在写一个要执行的任务类，如下： public class Prison { public Prison() {} public void execute() { List
如果要执行一些简单的定时器任务，无须做复杂的控制，也无须保存状态，那么可以考虑使用JDK 入门级的定期器Timer 来执行重复任务。 一、原理 JDK中，定时器任务的执行需要两个基本的类： java.util.Timer; java.util.TimerTask; 要运行一个定时任务，最基本的步骤如下： 1、建立一个要执行的任务TimerTask。 2、创建一个Timer实例，通过Timer提供的schedule()方法，将TimerTask加入到定时器Timer中，同时设置执行的规则即可。 当程序执行了Timer初始化代码后，Timer定时任务就会按照设置去执行。 Timer中的schedule()方法是有多种重载格式的，以适应不同的情况。该方法的格式如下： void schedule(TimerTask task, Date time) 安排在指定的时间执行指定的任务。 void schedule(TimerTask task, Date firstTime, long period) 安排指定的任务在指定的时间开始进行重复的固定延迟执行。 void schedule(TimerTask task, long delay) 安排在指定延迟后执行指定的任务。 void schedule(TimerTask task, long delay, long period) 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。 Timer是线程安全的，此类可扩展到大量同时安排的任务（存在数千个都没有问题）。其所有构造方法都启动计时器线程。可以调用cancel() 终止此计时器，丢弃所有当前已安排的任务。purge()从此计时器的任务队列中移除所有已取消的任务。此类不提供实时保证：它使用Object.wait(long) 方法来安排任务。 TimerTask是一个抽象类，由Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()----计时器任务要执行的操作。因此，每个具体的任务类都必须继承TimerTask类，并且重写run()方法。另外它还有两个非抽象的方法：boolean cancel() 取消此计时器任务。 long scheduledExecutionTime() 返回此任务最近实际执行的安排执行时间。 二、例子 下面用Timer实现一个简单例子： package stu.timer; import java.util.Date;
//这是我的定时器类，用来定时执行某段任务； package com.my.time; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; public class BugXmlTimer { public Timer timer; public void timerStart(){ timer = new Timer(); Date datetime=new Date(); Date midnightDate=new Date(); SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd"); SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); try { midnightDate = sdf2.parse(sdf1.format(datetime)+" 23:00:00"); } catch (ParseException e) { // TODO Auto-generated catch block e.printStackTrace(); } long in=midnightDate.getTime()-datetime.getTime(); System.out.println("before task"); //立刻执行，然后每隔30s执行一次 timer.schedule(new BugXmlTimerTask(), 0,30000);
jsp (web)定时器，Java定时器在Web中的应用 这个类最终功能是每天某个时间点(如每晚22点)执行某一功能。 首先，介绍java定时器（java.util.Timer）有定时执行计划任务的功能，通过设定定时器的间隔时间，会自动在此间隔时间后执行预先安排好的任务(java.util. TimerTask) 如: 每隔一个小时执行任务timer.schedule(TimerT ask, 0, 60 * 60 * 1000)。 schedule方法的第一个参数是需要执行的任务,此类的类型为java.util.TimerTask， 第二个参数为执行任务前等待时间,此处0表示不等待，第三个参数为间隔时间,单位为毫秒。由于我们希望当Web工程启动时，定时器能自动开始计时，这样在整个Web工程的生命期里,就会定时的执行任务，因此启动定时器的类不能是一般的类，此处用Servlet的监听器类来启动定时器,通过在配置文件里配置此监听器, 让其在工程启动时自动加载运行，存活期为整个Web工程生命期。 要使用此监听器需要在web.xml中配置,如下: 1
如何用javamail定时发送邮件 例如：我想在3天后的中午12：00发送给别人邮件 还有就是每天的中午12点给别人发送邮件，而且这些个邮件地址是从一个jsp传来的 例如今天给a@https://www.doczj.com/doc/1813516196.html,发，当执行过jsp后,jsp输入的是b@https://www.doczj.com/doc/1813516196.html,,以后就给b@https://www.doczj.com/doc/1813516196.html,发 而且jsp传过来的邮件地址数目是多个的，每天需要给多人在固定一时间内发邮件 定时触发器 有许多开源项目 Timer + 多线程 我在这里使用的Java计时器框架是由Java开发人员Tom White构建的一个简单通用的计划框架，以用于执行任意复杂的计划任务，他使我们实现灵活的计划策略成为可能。Java计时器框架的本身在这里不作过多的介绍，详细信息在IBM developerWorks中国网站。 我们主要讨论如何利用Java计时器框架在Solaris平台来实现邮件的定时发送、JavaMail发送邮件的实现以及在Solaris平台上如何以后台方式运行整个邮件定时发送的应用。 下载本文的源代码，参考具体实现。 1.1 形成schedule.jar包 schedule.jar包中的目录结构如下： 我们将数据库的连接、日志、邮件和计划框架的通用类形成一个与具体应用要求无关的schedule.jar包。利用javac将编译生成的目标class文件存在当前目录的classes文件夹下，然后通过jar -cvf schedule.jar ./*命令生成schedule.jar包。 1.1.1 Oracle数据库连接的建立 位于db目录下，通过thin方式建立与Oracle的数据库连接，具体的实现参见《J2EE应用中与Oracle数据库的连接》一文。 1.1.2 日志 以后台方式定时运行的应用应特别注意日志的功能，因为只有通过分析详细的日志信息才能准确掌握应用的执行情况。在logs目录下为Logs.java文件，代码如下： package com.j2ee.logs; import java.io.*; import java.util.*; import java.text.SimpleDateFormat;
用java.util.Timer定时执行任务 1.新建一个task 实现run方法 2.Timer t = new Time（） 3. T.schedule(task );等等4个方法去执行 如果要在程序中定时执行任务，可以使用java.util.Timer这个类实现。使用Timer类需要一个继承了java.util.TimerTask的类。TimerTask是一个虚类，需要实现它的run方法，实际上是他implements了Runnable接口，而把run方法留给子类实现。 下面是我的一个例子： class Worker extends TimerTask { public void run() { System.out.println("我在工作啦！"); } } Timer类用schedule方法或者scheduleAtFixedRate方法启动定时执行，schedule 重载了四个版本，scheduleAtFixedRate重载了两个。每个方法的实现都不同，下面是每个方法的说明： schedule public void schedule(TimerTask task, long delay) Schedules the specified task for execution after the specified delay. Parameters: task - task to be scheduled. delay - delay in milliseconds before task is to be executed.
Throws: IllegalArgumentException - if delay is negative, or delay + System.currentTimeMillis() is negative. IllegalStateException- if task was already scheduled or cancelled, or timer was cancelled. 说明：该方法会在设定的延时后执行一次任务。 schedule public void schedule(TimerTask task, Date time) Schedules the specified task for execution at the specified time. If the time is in the past, the task is scheduled for immediate execution. Parameters: task - task to be scheduled. time - time at which task is to be executed. Throws: IllegalArgumentException - if time.getTime() is negative. IllegalStateException - if task was already scheduled or cancelled, timer was cancelled, or timer thread terminated. 说明：该方法会在指定的时间点执行一次任务。 schedule public void schedule(TimerTask task, long delay, long period)
java定时任务，每天定时执行任务 public class TimerManager { //时间间隔 private static final long PERIOD_DAY = 24 * 60 * 60 * 1000; public TimerManager() { Calendar calendar = Calendar.getInstance(); /*** 定制每日2:00执行方法***/ calendar.set(Calendar.HOUR_OF_DAY, 2); calendar.set(Calendar.MINUTE, 0); calendar.set(Calendar.SECOND, 0); Date date=calendar.getTime(); //第一次执行定时任务的时间 //如果第一次执行定时任务的时间小于当前的时间 //此时要在第一次执行定时任务的时间加一天，以便此任务在下个时间点执行。如果不加一天，任务会立即执行。 if (date.before(new Date())) { date = this.addDay(date, 1); }
Timer timer = new Timer(); NFDFlightDataTimerTask task = new NFDFlightDataTimerTask(); //安排指定的任务在指定的时间开始进行重复的固定延迟执行。 timer.schedule(task,date,PERIOD_DAY); } // 增加或减少天数 public Date addDay(Date date, int num) { Calendar startDT = Calendar.getInstance(); startDT.setTime(date); startDT.add(Calendar.DAY_OF_MONTH, num); return startDT.getTime(); } } 在TimerManager 这个类里面，大家一定要注意时间点的问题。如果你设定在凌晨2点执行任务。但你是在2点以后 发布的程序或是重启过服务，那这样的情况下，任务会立即执行，而不是等到第二天的凌晨2点执行。为了，避免这种情况 发生，只能判断一下，如果发布或重启服务的时间晚于定时执行任务的时间，就在此基础上加一天。public class NFDFlightDataTimerTask extends TimerTask { private static Logger log = Logger.getLogger(NFDFlightDataTimerTask.class); @Override public void run() { try { //在这里写你要执行的内容
所有类型的Java 应用程序一般都需要计划重复执行的任务。企业应用程序需要计划每日的日志或者晚间批处理过程。一个J2SE 或者J2ME 日历应用程序需要根据用户的约定计划闹铃时间。不过，标准的调度类Timer 和TimerTask 没有足够的灵活性，无法支持通常需要的计划任务类型。在本文中，Java 开发人员Tom White 向您展示了如何构建一个简单通用的计划框架，以用于执行任意复杂的计划任务。 我将把java.util.Timer 和java.util.TimerTask 统称为Java 计时器框架，它们使程序员可以很容易地计划简单的任务（注意这些类也可用于J2ME 中）。在Java 2 SDK, Standard Edition, Version 1.3 中引入这个框架之前，开发人员必须编写自己的调度程序，这需要花费很大精力来处理线程和复杂的Object.wait() 方法。不过，Java 计时器框架没有足够的能力来满足许多应用程序的计划要求。甚至一项需要在每天同一时间重复执行的任务，也不能直接使用Timer 来计划，因为在夏令时开始和结束时会出现时间跳跃。 本文展示了一个通用的Timer 和TimerTask 计划框架，从而允许更灵活的计划任务。这个框架非常简单——它包括两个类和一个接口——并且容易掌握。如果您习惯于使用Java 定时器框架，那么您应该可以很快地掌握这个计划框架。 计划单次任务 计划框架建立在Java 定时器框架类的基础之上。因此，在解释如何使用计划框架以及如何实现它之前，我们将首先看看如何用这些类进行计划。 想像一个煮蛋计时器，在数分钟之后（这时蛋煮好了）它会发出声音提醒您。清单1 中的代码构成了一个简单的煮蛋计时器的基本结构，它用Java 语言编写： 清单1. EggTimer 类