在Java中如何设置一个定时任务，在每天的一个时间点自动执行一个特定的程序？具体代码怎么写？代码全点

Quartz定时机制

创新互联拥有十年成都网站建设工作经验,为各大企业提供成都做网站、网站建设服务，对于网页设计、PC网站建设（电脑版网站建设）、成都app软件开发公司、wap网站建设（手机版网站建设）、程序开发、网站优化（SEO优化）、微网站、国际域名空间等，凭借多年来在互联网的打拼，我们在互联网网站建设行业积累了很多网站制作、网站设计、网络营销经验，集策划、开发、设计、营销、管理等网站化运作于一体，具备承接各种规模类型的网站建设项目的能力。

首先导入jar包到程序内 quartz-all-1.6.0.jar

然后创建一个XML

TimeConfig.xml 名字可以自己定义

?xml version="1.0" encoding="UTF-8"?

!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"

""

beans

bean id="mainTask" class="net.timed.MainTask"/ //你要执行的任务类

//jar类

bean id="mainJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"

property name="targetObject"

ref bean="mainTask"///将你的类添加到定时器当中

/property

property name="targetMethod"

valueexecute/value //定时执行类里面的哪个方法

/property

/bean

bean id="timeTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"

property name="jobDetail"

ref bean="mainJob"/

/property

!--

0 0 10,14,16 * * ? 每天上午10点，下午2点，4点

0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时

0 0 12 ? * WED 表示每个星期三中午12点

"0 0 12 * * ?" 每天中午12点触发

"0 15 10 ? * *" 每天上午10:15触发

"0 15 10 * * ?" 每天上午10:15触发

"0 15 10 * * ? *" 每天上午10:15触发

"0 15 10 * * ? 2005" 2005年的每天上午10:15触发

"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发

"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发

"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发

"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发

"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发

"0 15 10 15 * ?" 每月15日上午10:15触发

"0 15 10 L * ?" 每月最后一日的上午10:15触发

"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发

"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发

"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

上面这个是quartz的语法 定时单位

--

property name="cronExpression"

value0 0/5 * * * ?/value //定时的语法

/property

/bean

bean id="sfb" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"

property name="triggers"

list

ref local="timeTrigger"/

/list

/property

/bean

/beans

//下面这个类就是我在XML中引入的类

package net.timed;

import java.io.IOException;

import java.text.SimpleDateFormat;

import java.util.Date;

public class MainTask {

public void execute() throws IOException

{

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println("do my job"+dateFormat.format(new Date()));

Runtime.getRuntime().exec("cmd /c start E:/mbl/BusinessOffice/MoneDB/bin/bakup.bat");

}

}

然后在web.xml中把这个TimeConfig.xml添加进去作为监听

系统启动的时候自动就监听这个事件

?xml version="1.0" encoding="UTF-8"?

web-app version="2.5"

xmlns=""

xmlns:xsi=""

xsi:schemaLocation="

"

context-param

param-name

contextConfigLocation

/param-name

param-value

/WEB-INF/TimerConfig.xml

/param-value

/context-param

listener

listener-class

org.springframework.web.context.ContextLoaderListener

/listener-class

/listener

welcome-file-list

welcome-fileindex.jsp/welcome-file

/welcome-file-list

/web-app

这个是quartz spring的定时机制 请仔细的看看 如果可以请给分哦

java 怎么写定时任务

如果要执行一些简单的定时器任务，无须做复杂的控制，也无须保存状态，那么可以考虑使用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;

import java.util.TimerTask;

/**

* 重复执行的任务

*

* @author leizhimin，2008-10-9 9:20:20

*/

public class TestTimerTask extends TimerTask {

/**

* 此计时器任务要执行的操作。

*/

public void run() {

Date executeTime = new Date(this.scheduledExecutionTime());

System.out.println("本次任务执行的时间是" + executeTime);

}

}

package stu.timer;

import java.util.Timer;

import java.util.TimerTask;

/**

* 测试JDK Timer的执行

*

* @author leizhimin，2008-10-9 9:24:35

*/

public class TestTimer {

public static void main(String[] args) {

Timer timer = new Timer();

TimerTask task = new TestTimerTask();

timer.schedule(task, 500L, 1000L);

}

}

运行结果：

本次任务执行的时间是Thu Oct 09 09:47:57 CST 2008

本次任务执行的时间是Thu Oct 09 09:47:58 CST 2008

本次任务执行的时间是Thu Oct 09 09:47:59 CST 2008

本次任务执行的时间是Thu Oct 09 09:48:00 CST 2008

本次任务执行的时间是Thu Oct 09 09:48:01 CST 2008

本次任务执行的时间是Thu Oct 09 09:48:02 CST 2008

本次任务执行的时间是Thu Oct 09 09:48:03 CST 2008

本次任务执行的时间是Thu Oct 09 09:48:04 CST 2008

本次任务执行的时间是Thu Oct 09 09:48:05 CST 2008

......

java代码启动一个定时任务

在应用里经常都有用到在后台跑定时任务的需求。举个例子，比如需要在服务后台跑一个定时任务来进行非实时计算，清除临时数据、文件等。在本文里，3种不同的实现方法：

普通thread实现

TimerTask实现

ScheduledExecutorService实现

1.普通thread

这是最常见的，创建一个thread，然后让它在while循环里一直运行着，通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：

public class Task1 {

public static void main(String[] args) {

// run in a second

final long timeInterval = 1000;

Runnable runnable = new Runnable() {

public void run() {

while (true) {

// ------- code for task to run

System.out.println("Hello !!");

// ------- ends here

try {

Thread.sleep(timeInterval);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

Thread thread = new Thread(runnable);

thread.start();

}

}

2.用Timer和TimerTask

上面的实现是非常快速简便的，但它也缺少一些功能。

用Timer和TimerTask的话与上述方法相比有如下好处：

当启动和去取消任务时可以控制

第一次执行任务时可以指定你想要的delay时间

在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。

Timer实例可以调度多任务。

当Timer的构造器被调用时，创建了一个线程，这个线程可以用来调度任务：

import java.util.Timer;

import java.util.TimerTask;

public class Task2 {

public static void main(String[] args) {

TimerTask task = new TimerTask() {

@Override

public void run() {

// task to run goes here

System.out.println("Hello !!!");

}

};

Timer timer = new Timer();

long delay = 0;

long intevalPeriod = 1 * 1000;

// schedules the task to be run in an interval

timer.scheduleAtFixedRate(task, delay,

intevalPeriod);

} // end of main

}

3.ScheduledExecutorService

ScheduledExecutorService是从Java SE 5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。

相比于上两个方法，它有以下好处：

相比于Timer的单线程，它是通过线程池的方式来执行任务的

可以很灵活的去设定第一次执行任务delay时间

提供了良好的约定，以便设定执行的时间间隔

通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间：

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

public class Task3 {

public static void main(String[] args) {

Runnable runnable = new Runnable() {

public void run() {

// task to run goes here

System.out.println("Hello !!");

}

};

ScheduledExecutorService service = Executors

.newSingleThreadScheduledExecutor();

service.scheduleAtFixedRate(runnable, 0, 1, TimeUnit.SECONDS);

}

}

java定时任务怎么实现

/**

* 普通thread

* 这是最常见的，创建一个thread，然后让它在while循环里一直运行着，

* 通过sleep方法来达到定时任务的效果。这样可以快速简单的实现，代码如下：

* @author GT

*

*/

public class Task1 {

public static void main(String[] args) {

// run in a second

final long timeInterval = 1000;

Runnable runnable = new Runnable() {

public void run() {

while (true) {

// ------- code for task to run

System.out.println("Hello !!");

// ------- ends here

try {

Thread.sleep(timeInterval);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

Thread thread = new Thread(runnable);

thread.start();

}

}

[java] view plain copy

import java.util.Timer;

import java.util.TimerTask;

/**

*

* 于第一种方式相比，优势 1当启动和去取消任务时可以控制 2第一次执行任务时可以指定你想要的delay时间

*

* 在实现时，Timer类可以调度任务，TimerTask则是通过在run()方法里实现具体任务。 Timer实例可以调度多任务，它是线程安全的。

* 当Timer的构造器被调用时，它创建了一个线程，这个线程可以用来调度任务。 下面是代码：

*

* @author GT

*

*/

public class Task2 {

public static void main(String[] args) {

TimerTask task = new TimerTask() {

@Override

public void run() {

// task to run goes here

System.out.println("Hello !!!");

}

};

Timer timer = new Timer();

long delay = 0;

long intevalPeriod = 1 * 1000;

// schedules the task to be run in an interval

timer.scheduleAtFixedRate(task, delay, intevalPeriod);

} // end of main

}

[java] view plain copy

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

/**

*

*

* ScheduledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。

* 相比于上两个方法，它有以下好处：

* 1相比于Timer的单线程，它是通过线程池的方式来执行任务的

* 2可以很灵活的去设定第一次执行任务delay时间

* 3提供了良好的约定，以便设定执行的时间间隔

*

* 下面是实现代码，我们通过ScheduledExecutorService#scheduleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了delay时间。

*

*

* @author GT

*

*/

public class Task3 {

public static void main(String[] args) {

Runnable runnable = new Runnable() {

public void run() {

// task to run goes here

System.out.println("Hello !!");

}

};

ScheduledExecutorService service = Executors

.newSingleThreadScheduledExecutor();

// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间

service.scheduleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);

}

}

分享题目：java灵活定时任务代码 java定时任务怎么触发
文章转载：http://scyanting.com/article/dogpiei.html