我们在实际开发中,多多少少都会用到定时任务来处理一些问题。
比如金融项目中的对账,每天定时对昨天的账务进行核对,每个月初对上个月的账务进行核对等。
还比如,我们需要处理一些老数据迁移,修复一些新项目和老项目数据不兼容的问题等等。
学习资料的:0 基础 Java 自学之路(配套教程)
这个目前在项目中用得较少,直接贴demo代码。
具体的介绍可以查看api ,但是在某些框架中是有用到。
public class TestTimer {
public static void main(String[] args) {
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
System.out.println("task run:"+ new Date());
}
};
Timer timer = new Timer();
//安排指定的任务在指定的时间开始进行重复的固定延迟执行。这里是每3秒执行一次
timer.schedule(timerTask,10,3000);
}
}
执行结果:
task run:Sun Dec 11 21:23:47 CST 2022
task run:Sun Dec 11 21:23:50 CST 2022
task run:Sun Dec 11 21:23:53 CST 2022
这么使用,阿里代码检查插件会提示:
从提示中可以看出,在多线程并行处理定时任务时,Timer运行多个TimerTask时,只要有其中之一没有捕获抛出的异常,其他任务会自动终止运行。
和Timer类型,也就是阿里代码检查插件推荐的方案:
public class TestScheduledExecutorService {
public static void main(String[] args) {
ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
// 参数:1、任务体 2、首次执行的延时时间
// 3、任务执行间隔 4、间隔时间单位
service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);
}
}
运行结果:
task ScheduledExecutorService Sun Dec 11 21:30:06 CST 2022
task ScheduledExecutorService Sun Dec 11 21:30:09 CST 2022
task ScheduledExecutorService Sun Dec 11 21:30:12 CST 2022
阿里代码检查插件也会提示:
这里提示的是我们创建线程池的方式,建议我们使用手动创建线程池,不要使用Executors
工厂类,因为手动创建更能有效规划资源的使用。
用起来也非常简单:
@Slf4j
@Component
public class ScheduledService {
@Scheduled(cron = "0/5 * * * * *")
public void scheduled(){
log.info("=====>>>>>使用cron {}",System.currentTimeMillis());
}
@Scheduled(fixedRate = 5000)
public void scheduled1() {
log.info("=====>>>>>使用fixedRate{}", System.currentTimeMillis());
}
@Scheduled(fixedDelay = 5000)
public void scheduled2() {
log.info("=====>>>>>fixedDelay{}",System.currentTimeMillis());
}
}
运行结果:
2022-12-11 21:36:25.001 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用cron 1670765785001
2022-12-11 21:36:28.212 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用fixedRate1670765788212
2022-12-11 21:36:28.212 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>fixedDelay1670765788212
2022-12-11 21:36:30.001 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用cron 1670765790001
2022-12-11 21:36:33.212 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用fixedRate1670765793212
2022-12-11 21:36:33.213 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>fixedDelay1670765793213
2022-12-11 21:36:35.001 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用cron 1670765795001
2022-12-11 21:36:38.214 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用fixedRate1670765798214
2022-12-11 21:36:38.214 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>fixedDelay1670765798214
2022-12-11 21:36:40.001 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用cron 1670765800001
2022-12-11 21:36:43.214 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>使用fixedRate1670765803214
2022-12-11 21:36:43.215 INFO 10660 --- [ scheduling-1] com.tian.utils.ScheduledService : =====>>>>>fixedDelay1670765803215
基于注解设定多线程定时任务 :
@Component
@EnableScheduling // 1.开启定时任务
@EnableAsync // 2.开启多线程
public class MultithreadScheduleTask {
@Async
@Scheduled(fixedDelay = 5000) //间隔5秒
public void first() throws InterruptedException {
System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
System.out.println();
Thread.sleep(1000 * 10);
}
@Async
@Scheduled(fixedDelay = 5000)
public void second() {
System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
System.out.println();
}
}
运行结果:
第一个定时任务开始 : 21:44:02.800
线程 : 入库操作日志记录表 线程1
第二个定时任务开始 : 21:44:02.801
线程 : 入库操作日志记录表 线程2
第一个定时任务开始 : 21:44:07.801
线程 : 入库操作日志记录表 线程3
第二个定时任务开始 : 21:44:07.802
线程 : 入库操作日志记录表 线程4
第一个定时任务开始 : 21:44:12.807
线程 : 入库操作日志记录表 线程5
第二个定时任务开始 : 21:44:12.812
线程 : 入库操作日志记录表 线程6
......
我们需要引入依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
实现类:
public class Myquartz extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
System.out.println("这是我的 quartz 定时任务");
}
}
配置类:
/**
* @author tianwc 公众号:java后端技术全栈、面试专栏
* @version 1.0.0
* @date 2022年12月11日 21:48
*/
@Configuration
public class QuartzConfig {
@Bean
public JobDetail teatQuartzDetail(){
return JobBuilder.newJob(MyQuartz.class).withIdentity("myQuartz").storeDurably().build();
}
@Bean
public Trigger testQuartzTrigger(){
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(10) //设置时间周期单位秒
.repeatForever();
return TriggerBuilder.newTrigger().forJob(teatQuartzDetail())
.withIdentity("testQuartz")
.withSchedule(scheduleBuilder)
.build();
}
}
只要启动Spring Boot项目,就会输出:
这是我的 quartz 定时任务
这是我的 quartz 定时任务
这是我的 quartz 定时任务
我们在项目,可能会涉及动态调整定时任务执行core表达式、动态关闭开启定时任务,我们可以使用SchedulingConfigurer
来实现(使用数据库结合来搞):
比如:
@Configuration
public class ScheduledConfig implements SchedulingConfigurer {
@Autowired
private ApplicationContext context;
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
for (SpringScheduledCron springScheduledCron : cronRepository.findAll()) {
Class<?> clazz;
Object task;
try {
clazz = Class.forName(springScheduledCron.getCronKey());
task = context.getBean(clazz);
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException("spring_scheduled_cron表数据" + springScheduledCron.getCronKey() + "有误", e);
} catch (BeansException e) {
throw new IllegalArgumentException(springScheduledCron.getCronKey() + "未纳入到spring管理", e);
}
Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定时任务类必须实现ScheduledOfTask接口");
// 可以通过改变数据库数据进而实现动态改变执行周期
taskRegistrar.addTriggerTask(((Runnable) task),
triggerContext -> {
//这个可以使用持久层,比如Mybatis来实现,从数据库中获取
String cronExpression = "0/10 * * * * ? "
return new CronTrigger(cronExpression).nextExecutionTime(triggerContext);
}
);
}
}
@Bean
public Executor taskExecutor() {
return Executors.newScheduledThreadPool(10);
}
}
如果项目中用得到类似的,可以网上搜搜SchedulingConfigurer
便可实现。
进而再扩展,那就来到分布式任务调度了。
任务调度是指基于给定的时间点,给定的时间间隔或者给定执行次数自动得执行任务。任务调度是是操作系统的重要组成部分,而对于实时的操作系统,任务调度直接影响着操作系统的实时性能。任务调度涉及到多线程并发、运行时间规则定制及解析、线程池的维护等诸多方面的工作。
WEB服务器在接受请求时,会创建一个新的线程服务。但是资源有限,必须对资源进行控制,首先就是限制服务线程的最大数目,其次考虑以线程池共享服务的线程资源,降低频繁创建、销毁线程的消耗;然后任务调度信息的存储包括运行次数、调度规则以及运行数据等。一个合适的任务调度框架对于项目的整体性能来说显得尤为重要。
分布式任务调度框架有:cronsun、Elastic-job、saturn、lts、TBSchedule、xxl-job 等。
另外,就是cron表达式,推荐 http://www.pppet.net/
可以根据自己业务情况来,手动选择,自动生成表达式。
好了,今天就分享这么多。
面经系列:
精彩文章
联系客服