首页 > 编程语言 > java定时任务实现的4种方式小结
2020
10-10

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("=========================");
      }
    }, 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即可

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
   <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
  </dependency>

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参数,来开启,关闭,删除,对应的定时任务。

以上这篇java定时任务实现的4种方式小结就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持自学编程网。

编程技巧