java定时任务配置

Ⅰ java timer怎么才配置具体的定时任务去调用方法去执行呢

TimerTask那定义一个变量 private static boolean going = false; 然后修改run方法 public void run() { if (going)return; going = true; //做你的事情 going = false; } 这个可以保证2秒执行一次，如果一次任务超过两秒，下一次执行会在开始就结束。等待两秒后再检查 如果希望前一次任务若超过两秒，后一次直接在前一次执行结束立即开始 可以换用Thread Thread t = new Thread(){ private static boolean going = true; public void run() { while(going){ int start = System.currentTimeMillis(); //做你的事 int cost = System.currentTimeMillis() - start; if (cost < 2000) { try{ sleep(2000 - cost); }catch(Exception ex){} } } } }; t.start();

Ⅱ java中怎么实现定时功能

这个是我在网上找的不知道是不是你要的：

java定时任务Timer 关于定时任务，似乎跟时间操作的联系并不是很大，但是前面既然提到了定时任务，索性在这里一起解决了。设置定时任务很简单，用Timer类就搞定了。一、延时执行首先，我们定义一个类，给它取个名字叫TimeTask，我们的定时任务，就在这个类的main函数里执行。代码如下：
package test;
import java.util.Timer;
public class TimeTaskTest {
public static void main(String[] args){ Timer timer = new Timer();
timer.schele(new Task(), 60 * 1000);
}
}
解释一下上面的代码。上面的代码实现了这样一个功能，当TimeTask程序启动以后，过一分钟后执行某项任务。很简单吧：先new一个Timer对象，然后调用它的schele方法，这个方法有四个重载的方法，这里我们用其中一个，
public void schele(TimerTask task,long delay)
首先，第一个参数第一个参数就是我们要执行的任务。这是一个TimerTask对象，确切点说是一个实现TimerTask的类的对象，因为TimerTask是个抽象类。上面的代码里 面，Task就是我们自己定义的实现了TimerTask的类，因为是在同一个包里面，所以没有显性的import进来。Task类的代码如下
package test;
import java.util.TimerTask;
public class Task extends TimerTask { public void run()
{
System.out.println("定时任务执行");
}
}
我们的Task必须实现TimerTask的方法run，要执行的任务就在这个run方法里面，这里，我们只让它往控制台打一行字。第二个参数第二个参数是一个long型的值。这是延迟的时间，就是从程序开始以后，再过多少时间来执行定时任务。这个long型的值是毫秒数，所以前面我们的程序里面，过一分钟后执行用的参数值就是 60 * 1000。二、循环执行设置定时任务的时候，往往我们需要重复的执行这样任务，每隔一段时间执行一次，而上面的方法是只执行一次的，这样就用到了schele方法的是另一个重载函数public void schele(TimerTask task,long delay,long period)
前两个参数就不用说什么了，最后一个参数就是间隔的时间，又是个long型的毫秒数（看来java里涉及到时间的，跟这个long是脱不了干系了），比如我们希望上面的任务从第一次执行后，每个一分钟执行一次，第三个参数值赋60 * 1000就ok了。三、指定执行时间既然号称是定时任务，我们肯定希望由我们来指定任务指定的时间，显然上面的方法就不中用了，因为我们不知道程序什么时间开始运行，就没办法确定需要延时多少。没关系，schele四个重载的方法还没用完呢。用下面这个就OK了：
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)
没必要说什么了吧:)四、j2ee中的定时任务在实际的项目中，往往定时任务需要对web工程中的资源进行操作，这样一来，用上面的单个程序的方式可能就有点力不从心了，因为很多web工程的资源它操作不到。解决的办法是，使用Servlet，把执行定时任务的那些代码放到Servlet的init()函数里就可以了，这个easy，就没有必要再写示例代码了吧

Ⅲ java代码启动一个定时任务

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

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;
// scheles the task to be run in an interval
timer.scheleAtFixedRate(task, delay,
intevalPeriod);
} // end of main
}

3.ScheledExecutorService

ScheledExecutorService是从Java SE 5的java.util.concurrent里，做为并发工具类被引进的，这是最理想的定时任务实现方式。
相比于上两个方法，它有以下好处：

相比于Timer的单线程，它是通过线程池的方式来执行任务的
可以很灵活的去设定第一次执行任务delay时间
提供了良好的约定，以便设定执行的时间间隔

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

import java.util.concurrent.Executors;
import java.util.concurrent.ScheledExecutorService;
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 !!");
}
};
ScheledExecutorService service = Executors
.();
service.scheleAtFixedRate(runnable, 0, 1, TimeUnit.SECONDS);
}
}

Ⅳ 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定时器如何配置文件，就是下面这个题，该怎么做啊

这是一个设计类的题目.不是叫你去配置,目前java的时间任务框架已经比较成熟了

解决这个问题大概需要做一下工作

1 写一个xml的解释器类,或者用java的XML的解释器,用来解释定时任务xml配置文件

2 写一个任务管理类
在1解释完xml后,实际上就是根据xml的配置来执行定时任务了
题目中的接口,实际上就是模拟Thread类,用来执行任务
管理类就是根据配置来启动和关闭定时任务

Ⅶ 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中如何设置一个定时任务的代码应该怎么写

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

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)

Ⅸ JAVA定时执行任务，每天定时几点钟执行任务

案例: 你想让他几点执行都ok

1.MyJob02
//首先我们需要定义一个任务类，比如为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());
}
2.
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();

}

Ⅹ java的几种定时任务

java定时任务有三种：

- JDK自带 ：JDK自带的Timer以及JDK1.5+ 新增的ScheledExecutorService；

- Quartz ：简单却强大的JAVA作业调度框架

- Spring3.0以后自带的task ：可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多；

代码参考：

1. JDK 自带的定时器实现

   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 ");

   
   }

   
   }, new Date(System.currentTimeMillis() + 2000));

   
   }
   }

2. Quartz 定时器实现

   2.1 通过maven引入依赖（这里主要介绍2.3.0） 注意：shiro-scheler中依赖的是1.x版本 如果同时使用会冲突

   <!-- https://mvnrepository.com/artifact/org.quartz-scheler/quartz -->

   
   <dependency>

   
   <groupId>org.quartz-scheler</groupId>

   
   <artifactId>quartz</artifactId>

   
   <version>2.3.0</version>

   
   </dependency>

   2.2创建Job类

   public class TestJob implements Job{

   
   @Override
   public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

   
   println(Thread.currentThread().getName() + " test job begin " + DateUtil.getCurrentTimeStr());

   
   }
   }

   2.3调度任务

   public static void main(String[] args) throws InterruptedException, SchelerException {
   

   
   Scheler scheler = new StdSchelerFactory().getScheler();

   
   // 开始

   
   scheler.start();

   
   // job 唯一标识 test.test-1

   
   JobKey jobKey = new JobKey("test" , "test-1");

   
   JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();

   
   Trigger trigger = TriggerBuilder.newTrigger() .withIdentity("test" , "test")

// 延迟一秒执行

.startAt(new Date(System.currentTimeMillis() + 1000))

// 每隔一秒执行 并一直重复

.withSchele(SimpleScheleBuilder.simpleSchele().withIntervalInSeconds(1).repeatForever())
.build();

scheler.scheleJob(jobDetail , trigger);

Thread.sleep(5000);
// 删除job

scheler.deleteJob(jobKey);

}

3.Spring 相关的任务调度

3.1 配置文件实现

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

<task:scheled-tasks scheler="myScheler">

<task:scheled ref="job" method="test" cron="0 * * * * ?"/>

</task:scheled-tasks>

3.2注解实现

spring-schele.xml

<task:scheler id="myScheler" pool-size="10" />

// 启用注解

<task:annotation-driven scheler="myScheler"/>

@Component
public class Task{

@Scheled(cron="0/5 * * * * ? ") //每5秒执行一次
public void execute(){

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

System.out.println(sdf.format(DateTime.now().toDate())+"*********B任务每5秒执行一次进入测试");

}
}