java定时任务实现的4种方式小结

java定时任务实现的4种方式小结

1. java自带的Timer

Timer timer = new Timer();

timer.schedule(new TimerTask() {

@Override

public void run() {

System.out.println("Time's up!");

}

},3*1000,1000);

2.ScheduledThreadPool-线程池

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

System.out.println("=etFuFAyy========================");

}

}, 1000, 2000, TimeUnit.MILLISECONDS);

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

@Override

public void run() {

System.out.println(System.currentTimeMillis()+"<><>"+System.nanoTime());

}

}, 1000, 2000, TimeUnit.MILLISECONDS);

3.使用注解的形式：@Scheduled

@Component

public class SpringScheduled {

@Scheduled(initialDelay = 2000,fixedDelay = 5000)

public void doSomething() {

System.out.println("Spring自带的Scheduled执行了=======================");

}

}

//下面是开启

@SpringBootApplication

@EnableScheduling

public class DemoApplication {

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

SpringApplication application = new SpringApplication(DemoApplication.class);

application.addListeners(new ContextRefreshedEventListener());

application.run(args);

}

}

4.使用Quartz定时任务调度器

配置

@Configuration

public class QuartzConfig {

@Resource

private ScheduleTask scheduleTask;

/**

* 配置定时任务1

* @return

*/

@Bean(name="firstJobDetail")

public MethodInvokingJobDetailFactoryBean firstJobDetail(){

MethodInvokingJobDetailFactoryBean method = new MethodInvokingJobDetailFactoryBean();

// 为需要执行的实体类对应的对象

method.setTargetObject(scheduleTask);

// 需要执行的方法

method.setTargetMethod("test");

// 是否并发执行

method.setConcurrent(false);

return method;

}

/**

* 配置触发器1

* @param firstJobDetail

* @return

*/

@Bean(name="firstTrigger")

public SimpleTriggerFactoryBean firstTrigger(JobDetail firstJobDetail){

SimpleTriggerFactoryBean simpleBean = new SimpleTriggerFactoryBean();

simpleBean.setJobDetail(firstJobDetail);

// 设置任务启动延迟

simpleBean.setStartDelay(1000);

// 每1秒执行一次

simpleBean.setRepeatInterval(1000);

//设置重复计数

//simpleBean.setRepeatCount(0);

return simpleBean;

}

/**

* 配置Scheduler

*/

@Bean(name = "scheduler")

public SchedulerFactoryBean schedulerFactoryBean(Trigger firstTrigger){

SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();

factoryBean.setTriggers(firstTrigger);

return factoryBean;

}

}

要执行的任务

@Component

public class ScheduleTask {

public void test() {

System.out.println("====================================");

}

}

总结：

还有其他方式可以实现定时任务的方式，可以贴出来，讨论讨

补充知识：SpringBoot定时任务简单使用和自定义开启关闭修改周期

一、简单使用

1.pom加入基本springboot基本的starter即可

org.springframework.boot

spring-boot-starter

org.springframework.boot

spring-boot-starter-test

test

org.springframework.boot

spring-boot-devtools

true

2.@Scheduled 参数可以接受两种定时的设置，一种是我们常用的cron="*/6 * * * * ?",一种是 fixedRate = 6000，两种都表示每隔六秒打印一下内容。

fixedRate 说明

@Scheduled(fixedRate = 6000) ：上一次开始执行时间点之后6秒再执行

@Scheduled(fixedDelay = 6000) ：上一次执行完毕时间点之后6秒再执行

@Scheduled(initialDelay=1000, fixedRate=6000) ：第一次延迟1秒后执行，之后按fixedRate的规则每6秒执行一次

@Component

public class TimingTask {

private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");

@Scheduled(cron="*/6 * * * * ?")

private void process(){

System.out.println("this is scheduler task runing "+new Date());

}

@Scheduled(fixedRate = 6000)

public void reportCurrentTime() {

System.out.println("现在时间：" + dateFormat.format(new Date()));

}

}

3.启动类加上@EnableScheduling注解。

@SpringBootApplication(exclude = MongoAutoConfiguration.class)

@EnableScheduling

public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

}

}

4.运行结果

this is scheduler task runing Thu Jul 18 10:59:06 CST 2019

现在时间：10:59:10

this is scheduler task runing Thu Jul 18 10:59:12 CST 2019

现在时间：10:59:16

this is scheduler task runing Thu Jul 18 10:59:18 CST 2019

现在时间：10:59:22

this is scheduler task runing Thu Jul 18 10:59:24 CST 2019

现在时间：10:59:28

以上就是定时任务的简单使用。但是有时候，定时任务需要关闭，和开启，或者修改定时任务的运行周期，可以使用下面的方式实现.

二、高级使用，自定义定时任务，关闭，开启，修改周期

1.说明

ThreadPoolTaskScheduler：线程池任务调度类，能够开启线程池进行任务调度。

ThreadPoolTaskScheduler.schedule()方法会创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable（线程接口类） 和CronTrigger（定时任务触发器）

在ScheduledFuture中有一个cancel可以停止定时任务。

@RestController

@RequestMapping("/time")

public class DynamicScheduledTask {

private static String DEFAULT_CRON = "0/5 * * * * ?";

@Autowired

private ThreadPoolTaskScheduler threadPoolTaskScheduler;

private ScheduledFuture> future;

@Bean

public ThreadPoolTaskScheduler threadPoolTaskScheduler() {

return new ThreadPoolTaskScheduler();

}

@RequestMapping("/{id}/startCron")

public String startCron(@PathVariable("id") String id) {

future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger(DEFAULT_CRON));

System.out.println("DynamicTask.startCron()"+"------"+id);

return "startCron";

}

@RequestMapping("/{id}/stopCron")

public String stopCron(@PathVariable("id") String id) {

if (future != null) {

future.cancel(true);

}

System.out.println("DynamicTask.stopCron()"+"------"+id);

return "stopCron";

}

@RequestMapping("/{id}/changeCron10")

public String startCron10(@PathVariable("id") String id) {

stopCron(id);// 先停止，在开启.

future = threadPoolTaskScheduler.schedule(new MyRunnable(), new CronTrigger("*/10 * * * * *"));

System.out.println("DynamicTask.startCron10()"+"------"+id);

return "changeCron10";

}

private class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println("DynamicTask.MyRunnable.run()，" + new Date());

}

}

}

如果想，做成后台管理，添加删除定时任务，可以将定时任务，持久化到数据库，自定义开发MyRunnable定时任务的业务类，也持久化到数据库，然后，threadPoolTaskScheduler.schedule要的业务类，可通过反射实例化出来，传递，然后，通过url，id参数，来开启，关闭，删除，对应的定时任务。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。