java中定时任务

㈠ java 定时任务的几种实现方式

1. JDK 自带的定时器实现

   // schele(TimerTask task, long delay) 延迟 delay 毫秒 执行
   // schele(TimerTask task, Date time) 特定时间执行
   public static void main(String[] args) {
   for (int i = 0; i < 10; ++i) {
   new Timer("timer - " + i).schele(new TimerTask() {
   @Override
   public void run() {
   println(Thread.currentThread().getName() + " run ");
   }
   }, 1000);
   }
   }
   2. Quartz 定时器实现

   //首先我们需要定义一个任务类，比如为MyJob02 ，
   //该类需要继承Job类，然后添加execute(JobExecutionContext context)方法，在
   //这个方法中就是我们具体的任务执行的地方。
   //由希望由调度程序执行的组件实现的接口
   public class MyJob02 implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
   // TODO Auto-generated method stub
   // 执行响应的任务.
   System.out.println("HelloJob.execute,"+new Date());
   }
   }

   public class QuartzTest5 {
   
   public static void main(String[] args) throws Exception {
   //SchelerFactory 是一个接口，用于Scheler的创建和管理
   SchelerFactory factory = new StdSchelerFactory();
   //从工厂里面拿到一个scheler实例
   //计划表(可能翻译的不太贴切)，现在我们有了要做的内容，
   //与调度程序交互的主要API
   /*
   * Scheler的生命期，从SchelerFactory创建它时开始，
   到Scheler调用shutdown()方法时结束；Scheler被创建后，
   可以增加、删除和列举Job和Trigger，以及执行其它与调度相关的操作
   （如暂停Trigger）。但是，Scheler只有在调用start()方法后，
   才会真正地触发trigger（即执行job）
   */
   Scheler scheler = factory.getScheler();
   //具体任务.
   //用于定义作业的实例
   //JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。
   JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
   
   
   //Trigger（即触发器） - 定义执行给定作业的计划的组件
   //TriggerBuilder - 用于定义/构建触发器实例
   CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group1")
   .withSchele(CronScheleBuilder.cronSchele("0/1 * * * * ?")).build();
   scheler.scheleJob(job, trigger);
   scheler.start();
   
   
   }
   3. Spring boot 任务调度(这个非常容易实现)

   /*
   * 开启对定时任务的支持
   * 在相应的方法上添加@Scheled声明需要执行的定时任务。
   */
   @EnableScheling
   //@EnableScheling注解来开启对计划任务的支持
   public class Application {
   
   public static void main(String[] args) {
   SpringApplication.run(Application.class, args);
   }
   }

   @Component
   public class ScheledTasks {
   private Logger logger = LoggerFactory.getLogger(ScheledTasks.class);
   private int i=0;
   //0 0 0 2 * ?
   @Scheled(cron="* * * 2 * ?")
   //@Scheled 注解用于标注这个方法是一个定时任务的方法
   public void testFixDelay() {
   logger.info("执行方法"+i++);
   }
   

㈡ java定时任务实现的几种方式

可以直接用Trigger方式实现，也可以用使用开源的XXL-JOB实现，基于java的，参考搭建过程：网页链接

㈢ java 怎么写定时任务

如果要执行一些简单的定时器任务，无须做复杂的控制，也无须保存状态，那么可以考虑使用JDK 入门级的定期器Timer来执行重复任务。

一、原理

JDK中，定时器任务的执行需要两个基本的类：
java.util.Timer;
java.util.TimerTask;

要运行一个定时任务，最基本的步骤如下：
1、建立一个要执行的任务TimerTask。
2、创建一个Timer实例，通过Timer提供的schele()方法，将 TimerTask加入到定时器Timer中，同时设置执行的规则即可。

当程序执行了Timer初始化代码后，Timer定时任务就会按照设置去执行。

Timer中的schele()方法是有多种重载格式的，以适应不同的情况。该方法的格式如下：
void schele(TimerTask task, Date time)
安排在指定的时间执行指定的任务。
void schele(TimerTask task, Date firstTime, long period)
安排指定的任务在指定的时间开始进行重复的固定延迟执行。
void schele(TimerTask task, long delay)
安排在指定延迟后执行指定的任务。
void schele(TimerTask task, long delay, long period)
安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。

Timer是线程安全的，此类可扩展到大量同时安排的任务（存在数千个都没有问题）。其所有构造方法都启动计时器线程。可以调用cancel() 终止此计时器，丢弃所有当前已安排的任务。purge()从此计时器的任务队列中移除所有已取消的任务。此类不提供实时保证：它使用 Object.wait(long) 方法来安排任务。

TimerTask是一个抽象类，由 Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()----计时器任务要执行的操作。因此，每个具体的任务类都必须继承TimerTask类，并且重写run()方法。另外它还有两个非抽象的方法：
boolean cancel()
取消此计时器任务。
long scheledExecutionTime()
返回此任务最近实际 执行的安排 执行时间。

二、例子

下面用Timer实现一个简单例子：

package stu.timer;

import java.util.Date;
import java.util.TimerTask;

/**
* 重复执行的任务
*
* @author leimin，2008-10-9 9:20:20
*/
public class TestTimerTask extends TimerTask {
/**
* 此计时器任务要执行的操作。
*/
public void run() {
Date executeTime = new Date(this.scheledExecutionTime());
System.out.println("本次任务执行的时间是" + executeTime);
}
}

package stu.timer;

import java.util.Timer;
import java.util.TimerTask;

/**
* 测试JDK Timer的执行
*
* @author leimin，2008-10-9 9:24:35
*/
public class TestTimer {
public static void main(String[] args) {
Timer timer = new Timer();
TimerTask task = new TestTimerTask();
timer.schele(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中定时任务的几种实现

在开发测试工具的应用后台，经常听到同事说要做个定时任务把做日志处理，或者数据清理，包括做些复杂的业务计算逻辑，在选择定时任务的时候，怎么能够快速实现，并且选择一种更适合自己的方式呢？ 我这里把定时任务的实现收集整理了一些方法，希望可以帮到刚开始做定时任务的同学，写得不对的地方请指正。

㈤ Java下定时执行任务的方法有哪些

1）java.util.Timer
这个方法应该是最常用的，不过这个方法需要手工启动你的任务：
Timer timer=new Timer();
timer.schele(new ListByDayTimerTask(),10000,86400000);
这里的ListByDayTimerTask类必须extends TimerTask里面的run()方法。
2）ServletContextListener
这个方法在web容器环境比较方便，这样，在web server启动后就可以
自动运行该任务，不需要手工操作。
将ListByDayListener implements ServletContextListener接口，在
contextInitialized方法中加入启动Timer的代码，在contextDestroyed
方法中加入cancel该Timer的代码；然后在web.xml中，加入listener:
详细教程请参考： http://java.e800.com.cn/articles/2010/1012/1286862116545_1.html

㈥ 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
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;
// scheles the task to be run in an interval
timer.scheleAtFixedRate(task, delay, intevalPeriod);
} // end of main
}
[java] view plain
import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
import java.util.concurrent.TimeUnit;
/**
*
*
* ScheledExecutorService是从Java SE5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。
* 相比于上两个方法，它有以下好处：
* 1>相比于Timer的单线程，它是通过线程池的方式来执行任务的
* 2>可以很灵活的去设定第一次执行任务delay时间
* 3>提供了良好的约定，以便设定执行的时间间隔
*
* 下面是实现代码，我们通过ScheledExecutorService#scheleAtFixedRate展示这个例子，通过代码里参数的控制，首次执行加了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 !!");
}
};
ScheledExecutorService service = Executors
.();
// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间
service.scheleAtFixedRate(runnable, 10, 1, TimeUnit.SECONDS);
}
}

㈦ java怎么定时任务

不知道你是什么环境呢？

WEB 还是GUI

Timertimer=newTimer();
timer.schele(newTimerTask(){

@Override
publicvoidrun(){
//定时动作这里执行

}
},1000);

㈧ 24，Java中如何实现一个定时任务

• /**

• *普通thread

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

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

• *@authorGT

• *

• */

• publicclassTask1{

• publicstaticvoidmain(String[]args){

• //runinasecond

• finallongtimeInterval=1000;

• Runnablerunnable=newRunnable(){

• publicvoidrun(){

• while(true){

• //-------codefortasktorun

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

• //-------endshere

• try{

• Thread.sleep(timeInterval);

• }catch(InterruptedExceptione){

• e.printStackTrace();

• }

• }

• }

• };

• Threadthread=newThread(runnable);

• thread.start();

• }

• }

㈨ 在Java中如何设置一个定时任务的代码应该怎么写

指定定时任务的代码如下：

public void schele(TimerTask task,Date time)

比如,我们希望定时任务2006年7月2日0时0分执行,只要给第二个参数传一个时间设置为2006年7月2日0时0分的Date对象就可以了.

有一种情况是,可能我们的程序启动的时候,已经是2006年7月3日了,这样的话,程序一启动,定时任务就开始执行了.

schele最后一个重载的方法是

public void schele(TimerTask task,Date firstTime,long period)