当前位置:首页 » 编程语言 » java定时执行

java定时执行

发布时间: 2022-10-17 15:27:38

1. 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
......

2. java 定时器字自动执行方法

  1. 为了不阻塞主线程,定时器应该开辟一个子线程去完成。

  2. 需要每秒轮询检测时间点是否符合条件。

示例代码如下:

public static void main(String[] args){

new Thread(){

private SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");

public void run() {

while(true){

try {

String currentTimeStr = sdf.format(new Date());

System.out.println("w=" + currentTimeStr);

if(currentTimeStr.equals("00:00")){

A();

System.out.println(currentTimeStr);

}

sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

private void A(){

System.out.println("夜深了,该休息了。");

}

}.start();

//阻塞主线程,不让程序结束。

while(true);

}

3. java定时器 每天12点 固定执行一个方法

可以使用timer的schele方法实现定时任务,例如:把下面的new Date()参数换为你要定时的时间,创建一个线程执行你的任务

public class 定时 {

public static void main(String[] args) {
Timer timer = new Timer();
timer.schele(new myTest(), new Date());
}
}

class myTest extends TimerTask {

@Override
public void run() {
//你要执行的任务
}
System.out.println(hour + ":" + fen + ":" + sec + ":" + i);

}

修改一下就可以了

4. java定时执行一个方法

现在能想到的是三种方法能实现:
1、普通thread实现 :是最常见的,创建一个thread,然后让它在while循环里一直运行着,通过sleep方法来达到定时任务的效果。
2、TimerTask :启动和去取消任务时可以控制,第一次执行任务时可以指定你想要的delay时间。
3、ScheledExecutorService实现 :最理想的定时任务实现方式,相比于Timer的单线程,它是通过线程池的方式来执行任务的,可以很灵活的去设定第一次执行任务delay时间,提供了良好的约定,以便设定执行的时间间隔等。
希望能帮到你。

5. java定时器 每天凌晨 固定执行一个方法

二、如果是需要Tomcat启动就能执行,不需要main方法的定时器的话:
web.xml里面需要这么配置:

<listener>
<listener-class>
com.InitListener
</listener-class>
</listener>
第一个类:InitListener

package com.listener;
import java.util.Calendar;
import java.util.Date;
import java.util.Timer;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
* 系统启动时的监听类 初始化系统数据
*
* @author jhoneder
*
*/
public class InitListener implements ServletContextListener {
public void contextDestroyed(ServletContextEvent arg0) {
// TODO Auto-generated method stub
// context销毁时,销毁初始化数据
}
public void contextInitialized(ServletContextEvent event) {
// TODO Auto-generated method stub
try {
goTimmer();
} catch (Exception e) {
System.out.println("失败:" + e.getMessage());
}
}
private void goTimer() {
Timer timmerTask = new Timer();
Calendar calEnviron = Calendar.getInstance();
// 每天的02:00.am开始执行
calEnviron.set(Calendar.HOUR_OF_DAY, 2);
calEnviron.set(Calendar.MINUTE, 00);
// date为制定时间
Date dateSetter = new Date();
dateSetter = calEnviron.getTime();
// nowDate为当前时间
Date nowDateSetter = new Date();
// 所得时间差为,距现在待触发时间的间隔
long intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime();
if (intervalEnviron < 0) {
calEnviron.add(Calendar.DAY_OF_MONTH, 1);
dateSetter = calEnviron.getTime();
intervalEnviron = dateSetter.getTime() - nowDateSetter.getTime();
}
// 每24小时执行一次
timmerTask.schele(new UseTimer(timmerTask), intervalEnviron, 1 * 1000 * 60 * 60 * 24);
}
}

第二个类:

package com.listener;
import java.util.Timer;
import java.util.TimerTask;
/**
* 被调用执行类
*
* @author Administrator
*
*/
public class UseTimer extends TimerTask {
Timer timer = new Timer();
public UseTimer(Timer timer) {
this.timer = timer;
}
/*
* 被调用具体的方法
*/
public void run() {
System.out.println("开始具体执行!");
}
}

不懂得话可以追问!

6. 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秒执行一次进入测试");


}
}

7. 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++);
    }

8. 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();

}

9. 用java里timer执行定时任务,怎么写

Timer
timer
=
new
Timer();
timer.schele(new
MyTask(),
firstTime,
24*60*60*1000L);
timer.schele(new
MyTask(),
secondTime,24*60*60*1000L);
timer.schele(new
MyTask(),
ThirdTime,
24*60*60*1000L);
其中三个时间分别为一天的8:00/12:00/14:00点,可以用SimpleDateFormat类

10. JAVA实现定时任务的几种方式

Java 基本的定时任务,总结方法有三种:

1 创建一个thread,然后让它在while循环里一直运行着,通过sleep方法来达到定时任务的效果;

2 用Timer和TimerTask与第一种方法相比有如下好处:

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

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

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

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

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

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

热点内容
工控类编程 发布:2024-12-24 09:47:20 浏览:74
21款奕跑有哪些配置 发布:2024-12-24 09:47:19 浏览:783
教室系统管理员如何帮助更改密码 发布:2024-12-24 09:44:19 浏览:597
ip广播服务器安装 发布:2024-12-24 09:33:56 浏览:942
路由器如何配置ss 发布:2024-12-24 09:06:14 浏览:425
安卓lol怎么登录 发布:2024-12-24 08:54:11 浏览:701
安卓车机怎么更改软件分辨率 发布:2024-12-24 08:38:12 浏览:291
以图形化界面的方式执行存储过程 发布:2024-12-24 08:37:26 浏览:912
在哪里找得到退出存储卡 发布:2024-12-24 08:25:23 浏览:483
安卓上哪里下大型游戏 发布:2024-12-23 15:10:58 浏览:189