java Timer 定时每天凌晨1点执行任务 - 博客频道 - CSDN.NET
阿三、连起床这么困难的事你都做到了、接下来的一天还有什么能难倒你！！！
分类：java
import java.util.TimerT
* 执行内容
* @author admin_Hzw
public class Task extends TimerTask {
public void run() {
System.out.println(&我有一头小毛驴!&);
import java.util.C
import java.util.D
import java.util.T
* 任务管理
* @author admin_Hzw
public class TimerManager {
* @param args
public static void main(String[] args) {
new TimerManager();
//时间间隔(一天)
private static final long PERIOD_DAY = 24 * 60 * 60 * 1000;
public TimerManager() {
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.HOUR_OF_DAY, 1); //凌晨1点
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();
Task task = new Task();
//安排指定的任务在指定的时间开始进行重复的固定延迟执行。
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();
排名：第1697名
（69）（23）（4）（16）（28）（38）（4）（1）（1）（0）（12）（5）（2）（3）（3）（8）（3）（2）（8）（1）（1）（8）（8）（3）（2）（1）（2）（3）（1）（1）（2）（2）（2）（1）（1）（3）（0）（1）（2）（2）（1）定时任务:Java中Timer和TimerTask的使用 -
- ITeye博客
java.util.Timer定时器，实际上是个线程，定时调度所拥有的TimerTasks。
一个TimerTask实际上就是一个拥有run方法的类，需要定时执行的代码放到run方法体内，TimerTask一般是以匿名类的方式创建。
一个完整的Timer：
java.util.Timer timer = new java.util.Timer(true);
// true 说明这个timer以daemon方式运行（优先级低，
// 程序结束timer也自动结束），注意，javax.swing
// 包中也有一个Timer类，如果import中用到swing包，
// 要注意名字的冲突。
TimerTask task = new TimerTask() {
public void run() {
... //每次需要执行的代码放到这里面。
//以下是几种调度task的方法：
timer.schedule(task, time);
// time为Date类型：在指定时间执行一次。
timer.schedule(task, firstTime, period);
// firstTime为Date类型,period为long
// 从firstTime时刻开始，每隔period毫秒执行一次。
timer.schedule(task, delay)
// delay 为long类型：从现在起过delay毫秒执行一次
timer.schedule(task, delay, period)
// delay为long,period为long：从现在起过delay毫秒以后，每隔period
// 毫秒执行一次。
下面是一个完整的例子,由两个类组成,一个定制任务,一个调用java.util.Timer
import java.util.T
public class TimerTaskTest extends java.util.TimerTask{
public void run() {
// TODO Auto-generated method stub
System.out.println("start");
2.调用java.util.Timer
import java.util.T
public class Test {
public static void main(String[] args){
Timer timer = new Timer();
timer.schedule(new TimerTaskTest(), );
根据上面的介绍,便可以在1秒后,每隔2秒执行一次程序
浏览 91012
浏览: 94135 次
来自: 杭州
解释得有点问题，schedule 是 前一个任务结束时间跟后一 ...
例子不错，但是讲解的有点简单了，推荐这篇文章讲解的更详细一点： ...
很好，不错的例子。。谢谢。。
不错，刚好用到，看了这个例子。全部答案（共2个回答）
论坛查问一下.
你是不是装的有杀毒软件，有时杀毒软件会自认为是风险项，会自动禁用的。
玩回合制吧，不过回合制画面好的不多，推荐你试试3D回合制《桃园》，虚幻3引擎制作，经过深度优化，低配置实现高品质画面，游戏内容丰富有趣，最关键的是，免费，可挂机...
Option Explicit
Dim Time1 As Date '当前时间
Dim Time2 As Date '定时时间
Private Sub Fo...
在线程中定义一个状态变量，如果想停止这个线程，设置这个状态变量，在run的while条件对这个状态变量进行判断就可以了
不过这样要等线程的一次处理结束才会停止...
#清迈99号画廊酒店#房间可以上网吗？有网线吗
答: 买路由肯定可以,拿一根网线建个局域网也应该可以
答: 门户网站
门户（portal）。原意是指正门、入口，现多用于互联网的门户网站和企业应用系统的门户系统。
这里是一个应用框架，它...
大家还关注
确定举报此问题
举报原因(必选)：
广告或垃圾信息
激进时政或意识形态话题
不雅词句或人身攻击
侵犯他人隐私
其它违法和不良信息
报告，这不是个问题
报告原因(必选)：
这不是个问题
这个问题分类似乎错了
这个不是我熟悉的地区Java基础--定时任务Timer - 停留的风 - 博客园
posts - 234, comments - 1230, trackbacks - 5, articles - 27
Java基础--定时任务Timer
一、Timer介绍
&java.util.Timer
&java.util.TimerTask
Timer是一个定时器类，通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类，该类实现了Runnable接口，而且是一个抽象类，如下所示：
　　public abstract class TimerTask implements Runnable
　　可以通过继承该类，来实现自己的定时任务。
　　Timer定时器实例有多种构造方法：
　　Timer()
　　创建一个新计时器。
　　Timer(boolean isDaemon)
　　创建一个新计时器，可以指定其相关的线程作为守护程序运行。
　　Timer(String name)
　　创建一个新计时器，其相关的线程具有指定的名称。
　　Timer(String name, boolean isDaemon)
　　创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运行。
二、Timer方法
定时执行方法
1、在特定时间执行任务，只执行一次
public void schedule(TimerTask task,Date time)
2、在特定时间之后执行任务，只执行一次
public void schedule(TimerTask task,long delay)
3、指定第一次执行的时间，然后按照间隔时间，重复执行
public void schedule(TimerTask task,Date firstTime,long period)
4、在特定延迟之后第一次执行，然后按照间隔时间，重复执行
public void schedule(TimerTask task,long delay,long period)
delay： 延迟执行的毫秒数，即在delay毫秒之后第一次执行
period：重复执行的时间间隔
5、第一次执行之后，特定频率执行，与3同
public void scheduleAtFixedRate(TimerTask task,Date firstTime,long period)
6、在delay毫秒之后第一次执行，后按照特定频率执行
public void scheduleAtFixedRate(TimerTask task,long delay,long period)
方法名称schedule()和scheduleAtFixedRate()两者的区别
&1&schedule()方法更注重保持间隔时间的稳定：保障每隔period时间可调用一次&2&scheduleAtFixedRate()方法更注重保持执行频率的稳定：保障多次调用的频率趋近于period时间，如果任务执行时间大于period，会在任务执行之后马上执行下一次任务
timer.cancel();
1、特定时间后执行
public void schedule(TimerTask task,long delay)
task为：执行任务
delay：时间毫秒数
方法的含义：
在delay毫秒后执行任务task，只执行一次。
1分钟后同步数据。
同步任务：
package com.
import java.util.TimerT
public class SynchroTimerTask extends TimerTask {
public void run() {
// TODO Auto-generated method stub
System.out.println("Synchro data to other servers.");
定时任务：
package com.
import java.util.T
import java.util.TimerT
public class SynchroTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
TimerTask task = new SynchroTimerTask();
Timer timer = new Timer();
timer.schedule(task, 1000);
&2、案例2：按点吃饭
首先定义吃饭的任务，制定饭点，没小时进行检查，到点就吃饭。
package com.
import java.util.ArrayL
import java.util.C
import java.util.L
import java.util.TimerT
* 定时吃饭
public class EatTimerTask extends TimerTask {
//吃饭时间
private static List&Integer& eatT
* 静态初始化
initEatTimes();
* 初始化吃饭时间
private static void initEatTimes(){
eatTimes = new ArrayList&Integer&();
eatTimes.add(8);
eatTimes.add(12);
eatTimes.add(18);
public void run() {
// TODO Auto-generated method stub
Calendar calendar = Calendar.getInstance();
System.out.println("检查是否到了吃饭的点");
int hour = calendar.get(Calendar.HOUR_OF_DAY);
if(eatTimes.contains(hour))
System.out.println("饿了，吃饭...");
定时检查执行：
package com.
import java.util.C
import java.util.D
import java.util.T
import java.util.TimerT
public class EatTimerTaskTest {
public static void main(String[] arg){
TimerTask task = new EatTimerTask();
calendar= Calendar.getInstance();
Date firstTime = calendar.getTime();
//间隔：1小时
long period = 1000 * 60 * 60;
//测试时间每分钟一次
//period = 1000 * 60;
Timer timer = new Timer();
timer.schedule(task, firstTime, period);通过spring实现对所有定时任务进行AOP拦截，和实现每个定时任务执行的时间从数据库动态获得
通过spring实现对所有定时任务进行AOP拦截，和实现每个定时任务执行的时间从数据库动态获得，这样可以保证不需要重启容器就可以修改某个定时任务的执行时间
1.spring.xml配置AOP切面
&bean id="methodTimeAdvice"
class="cn.abc.mon.taskManager.MethodTimeAdvice"&
&&&&&/bean&
&!-- 每个定时任务AOP拦截获得执行时间 --&
&aop:config
proxy-target-class="true"&
&&&&&&&&&!--Spring
2.0 可以用 AspectJ 的语法定义 Pointcut，这里拦截 指定
包中的所有方法&--&&&&&
&&&&&&&&aop:advisor
id="methodTimeLog" advice-ref="methodTimeAdvice"
pointcut="execution(*
&&&&cn.abc.timertask.biz.*.*.*Task.work(..))
execution(*
cn.abc.timertask.biz.*.*.*Servlet.work(..))"/&
&/aop:config&
以下配置了两个bean，即两个定时任务
&!-- 配置一个bean
&bean id="huPaymentTask"
class="cn.abc.timertask.biz.fight.huPayment.HuPaymentTask"&
&!-- 定义调用对象和调用对象的方法 --&
id="huPaymentTask_schedulerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&!-- 调用的类 --&
&property name="targetObject"
ref="huPaymentTask" /&
&!-- 调用类中的方法 --&
&property name="targetMethod" value="work"
&!-- 定义触发时间 --&
&bean id="huPaymentTask_cronTrigger"
class="cn.abc.mon.taskManager.InitializingCronTrigger"&
&property name="taskid"
value="huPaymentTask"&&/property&
&property name="jobDetail"
ref="huPaymentTask_schedulerJobDetail" /&
&property name="scheduleInfoManager"
ref="scheduleInfoManager" /&
配置另一个bean &--&
&bean id="weatherTask"
class="cn.abc.timertask.biz.fight.weather.WeatherTask"&
&/bean& &!--
定义调用对象和调用对象的方法 --&&
&bean id="weatherTask_schedulerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&&
&&!-- 调用的类
&&property
name="targetObject" ref="weatherTask" /&
&&!-- 调用类中的方法
&&property
name="targetMethod" value="work" /&
&&!-- 定义触发时间
&bean id="weatherTask_cronTrigger"
class="cn.abc.mon.taskManager.InitializingCronTrigger"&
&&property
name="taskid"
value="weatherTask"&&/property&&
&&property
name="jobDetail" ref="weatherTask_schedulerJobDetail"
&&property
name="scheduleInfoManager" ref="scheduleInfoManager"
&!-- 从数据库获得并动态更新所有定时任务的时间
&bean id="schedulerFactoryTask"
class="cn.abc.mon.taskManager.SchedulerFactoryTask"&
&property name="schedulerFactory"
ref="schedulerFactory"/&
&property name="scheduleInfoManager"
ref="scheduleInfoManager"/&
&!-- 定义调用对象和调用对象的方法 --&
id="schedulerFactoryTask_schedulerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&!-- 调用的类 --&
&property name="targetObject"
ref="schedulerFactoryTask" /&
&!-- 调用类中的方法 --&
&property name="targetMethod" value="work"
&!-- 定义触发时间 --&
id="schedulerFactoryTask_cronTrigger"
class="cn.abc.mon.taskManager.InitializingCronTrigger"&
&property name="taskid"
value="schedulerFactoryTask"&&/property&
&property name="jobDetail"
ref="schedulerFactoryTask_schedulerJobDetail"
&property name="scheduleInfoManager"
ref="scheduleInfoManager" /&
&!-- 数据库操作类 --&
&bean id="scheduleInfoManager"
class="cn.abc.mon.taskManager.ScheduleInfoManager"/&
&!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序
&bean id="schedulerFactory" lazy-init="false"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="huPaymentTask_cronTrigger"
&ref local="weatherTask_cronTrigger"
&/property&
2.HuPaymentTask.java
一个定时任务类,WeatherTask.java与这个类似，就不写了
cn.abc.timertask.biz.fight.huP
public class HuPaymentTask {
public void work() {
System.out.println("这里写这个定时任务需要执行的操作代码");
3.MethodTimeAdvice.java
切面类，其中加入了将拦截的内容加入到数据库的代码，如果不需要可以相应删掉
package cn.abc.mon.taskM
import java.text.SimpleDateF
import java.util.D
import org.aopalliance.intercept.MethodI
import org.aopalliance.intercept.MethodI
import mons.lang.StringU
import mons.lang.time.StopW
import mons.logging.L
import mons.logging.LogF
import org.springframework.aop.ThrowsA
cn.abc.mon.taskManager.po.TaskD
public class MethodTimeAdvice implements MethodInterceptor
protected final Log log =
LogFactory.getLog(MethodTimeAdvice.class);
public Object invoke(MethodInvocation invocation) {
Object[] object = invocation.getArguments();
ScheduleInfoManager scheduleInfoManager = new
ScheduleInfoManager();//这个类封装了对数据库的增删改查操作
TaskDetail taskDetail = new TaskDetail();//这是一个实体
// 用 commons-lang 提供的 StopWatch 计时，Spring 也提供了一个
StopWatch clock = new StopWatch();
clock.start(); // 计时开始
String beforeTime = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS").format(new Date());
System.out.println("启动时间："+ beforeTime);
taskDetail.setTask_detail_startdate(beforeTime);
Object result =
result = invocation.proceed();
System.out.println(result);
taskDetail.setTask_detail_isexception("0");
} catch (Exception e) {
// TODO: handle exception
System.out.println("捕获的异常："+e.getMessage());
String exceptionTime = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS").format(new Date());
taskDetail.setTask_detail_isexception("1");
taskDetail.setTask_detail_exceptiondesc(e.getMessage());
taskDetail.setTask_detail_executedate(exceptionTime);
clock.stop(); // 切面结束
String endTime = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS").format(new Date());
System.out.println("结束时间："+ endTime);
taskDetail.setTask_detail_enddate(endTime);
// 方法参数类型，转换成简单类型
Class[] params =
invocation.getMethod().getParameterTypes();
String[] simpleParams = new String[params.length];
for (int i = 0; i & params. i++) {
simpleParams[i] = params[i].getSimpleName();
System.out.println("结束时间：" + clock.getTime() + " ms");
taskDetail.setTask_detail_executedate(clock.getTime() + "
System.out.println("每次执行时间:" + clock.getTime() + " ms");
System.out.println("操作类（包名+类名+方法名+（参数））： ["
+ invocation.getThis().getClass().getName() + "."
+ invocation.getMethod().getName() + "("
+ StringUtils.join(simpleParams, ",") + ")] ");
System.out.println(result);
//这里将拦截的数据插入的数据库
scheduleInfoManager.insertTaskDetail(taskDetail);
4.InitializingCronTrigger.java//每个定时器调用的初始化时间类
package cn.abc.mon.taskM
import java.io.S
import java.text.ParseE
org.springframework.scheduling.quartz.CronTriggerB
org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB
public class InitializingCronTrigger extends CronTriggerBean
implements Serializable {
private ScheduleInfoManager scheduleInfoM
public void setTaskid(String taskid) {
this.taskid =
public ScheduleInfoManager getScheduleInfoManager() {
return scheduleInfoM
public String getTaskid() {
// 设值注入，通过setter方法传入被调用者的实例scheduleInfoManager
& & public void
setScheduleInfoManager(ScheduleInfoManager
scheduleInfoManager){
System.out.println("----------------初始化"+taskid+"定时任务时间-----------------");
& this.scheduleInfoManager =
scheduleInfoM
& String cronExpression = "0 0 0 */1 *
?";//所有定时任务的执行时间都初始化为一天执行一次
setCronexpression_r(cronExpression);
if(taskid.equals("schedulerFactoryTask")){//如果调用的是总定时器
setCronexpression_r("0/10 * * * *
?");//设置总定时器每个10分钟更新一次所有的定时器的时间
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
&// ②
5.SchedulerFactoryTask.java
为所有定时器更新相应的执行时间
package cn.abc.mon.taskM
import java.sql.C
import java.sql.ResultS
import java.sql.SQLE
import java.sql.S
import java.text.ParseE
import java.util.ArrayL
import java.util.L
import org.quartz.S
import org.quartz.SchedulerE
import org.springframework.context.ApplicationC
org.springframework.context.support.ClassPathXmlApplicationC
org.springframework.scheduling.quartz.CronTriggerB
public class SchedulerFactoryTask {
private Scheduler schedulerF &
private ScheduleInfoManager scheduleInfoM
// 设值注入，通过setter方法传入被调用者的实例scheduler
public void setSchedulerFactory(Scheduler schedulerFactory)
this.schedulerFactory = schedulerF
public ScheduleInfoManager getScheduleInfoManager() {
return scheduleInfoM
public void setScheduleInfoManager(ScheduleInfoManager
scheduleInfoManager) {
this.scheduleInfoManager = scheduleInfoM
public void work(){
ApplicationContext context = new
ClassPathXmlApplicationContext("spring-triggers.xml");//spring-triggers.xml如下，其中是一个所有定时器名字的集合
List quartzList =
(ArrayList)context.getBean("quartzList");
for(int i = 0;i
CronTriggerBean trigger = (CronTriggerBean)
schedulerFactory.getTrigger(quartzList.get(i),
Scheduler.DEFAULT_GROUP); &
String dbCronExpression = "" ; &
dbCronExpression =
scheduleInfoManager.getCronExpressionFromDB(quartzList.get(i).split("_")[0]);
//System.out.println(trigger+"+++++");
String originConExpression =
trigger.getCronexpression_r();&
//System.out.println(trigger+"===="+originConExpression);
判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等
// 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
if(!originConExpression.equalsIgnoreCase(dbCronExpression)){
trigger.setCronexpression_r(dbCronExpression);
schedulerFactory.rescheduleJob(quartzList.get(i),
Scheduler.DEFAULT_GROUP, trigger); &
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ParseException e) {
// TODO: handle exception
e.printStackTrace();
6.spring-triggers.xml
这是一个所有定时任务名字的LIST，当然你也可以从数据库获得或其他方式定义
&?xml version="1.0"
encoding="UTF-8"?&
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans&
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd"&
&!-- 所有定时任务的id名字集合List --&
&bean id="quartzList"
class="java.util.ArrayList"&
&constructor-arg&
&value&huPaymentTask_cronTrigger&/value&
&value&weatherTask_cronTrigger&/value&
&/constructor-arg&
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。