Spring之两种任务调度Scheduled和Async详解

Spring之两种任务调度Scheduled和Async详解

目录1、Spring调度的两种方式2、@Schedule3、@Async4、Quartz登场@Scheduled 和@Async的使用

1、Spring调度的两种方式

Spring提供了两种后台任务的方法，分别是：

调度任务，@Schedule

异步任务，@Async

当然，使用这两个是有条件的，需要在spring应用的上下文中声明

当然，如果我们是基于java配置的，需要在配置哪里加多EnableScheduling和@EnableAsync 就像下面这样

@EnableScheduling

@EnableAsync

public class WebAppConfig {

....

｝

除此之外，还是有第三方库可以调用的，例如Quartz.

2、@Schedule

先看下@Schedule怎么调用再说

public final static long ONE_DAY = 24 * 60 * 60 * 1000;

public final static long ONE_HOUR = 60 * 60 * 1000;

@Scheduled(fixedRate = ONE_DAY)

public void scheduledTask() {

System.out.println(" 我是一个每隔一天就会执行一次的调度任务");

}

@Scheduled(fixedDelay = ONE_HOURS)

public void scheduleTask2() {

System.out.println(" 我是一个执行完后，隔一小时就会执行的任务");

}

@Scheduled(initialDelay=1000, fixedRate=5000)

public void doSomething() {

// something that should execute periodically

}

@Scheduled(cron = "0 0/1 * * * ? ")

public void ScheduledTask3() {

System.out.println(" 我是一个每隔一分钟就就会执行的任务");

}

需要注意的

关于最后一个，在指定时间执行的任务，里面使用的是Cron表达式，同时我们看到了两个不一样的面孔fixedDelay& fixedRate，前者fixedDelay表示在指定间隔运行程序，例如这个程序在今晚九点运行程序，跑完这个方法后的一个小时，就会再执行一次，而后者fixedDelay者是指，这个函数每隔一段时间就会被调用（我们这里设置的是一天），不管再次调度的时候，这个方法是在运行还是结束了。而前者就要求是函数运行结束后开始计时的，这就是两者区别。

这个还有一个initialDelay的参数，是第一次调用前需要等待的时间，这里表示被调用后的，推迟一秒再执行，这适合一些特殊的情况。

我们在serviceImpl类写这些调度任务时候，也需要在这些我们定义的serviceInterface的借口中写多这个接口，要不然会爆 but not found in any interface(s) for bean JDK proxy.Either pull the method up to an interface or

3、@Async

有时候我们会调用一些特殊的任务，任务会比较耗时，重要的是，我们不管他返回的后果。这时候我们就需要用这类的异步任务啦，调用后就让他去跑，不堵塞主线程，我们继续干别的。代码像下面这样:

public void AsyncTask(){

@Async

public void doSomeHeavyBackgroundTask(int sleepTime) {

try {

Thread.sleep(sleepTime);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

@Async

public Future doSomeHeavyBackgroundTask() {

try {

Thread.sleep(3000);

} catch (InterruptedException e) {

e.printStackTrace();

}

return null;

}

public void printLog() {

System.out.println(" i print a log ,time=" + System.currentTimeMillis());

}

}

我们写个简单的测试类来测试下

@RunWith(SpringJUnit4ClassRunner.class)

@WebAppConfiguration

@ContextConfiguration(classes = AsycnTaskConfig.class) //要声明@EnableASync

public class AsyncTaskTest {

@Autowired

AsyncTask asyncTask;

@Test

public void AsyncTaskTest() throws InterruptedException {

if (asyncTask != null) {

asyncTask.doSomeHeavyBackgroundTask(4000);

asyncTask.printLog();

Thread.sleep(5000);

}

}

}

这感觉比我们手动开多一个线程方便多了，不想异步的话直接把@Async去掉就可以了，另外如果你想要返回个结果的，这需要加多个Future<>,关于这个Future，完全可以写多几篇文章介绍，顺便把FutureTask介绍了。如果想修改Spring boot的默认线程池配置，可以实现AsyncConfigurer.

需要注意的：

相对于@scheduled，这个可以有参数和返回个结果，因为这个是我们调用的，而调度的任务是spring调用的。

异步方法不能内部调用，只能像上面那样，外部调用，否则就会变成阻塞主线程的同步任务啦！这个坑我居然跳下去了！例如下面这样的。

public void AsyncTask(){

public void fakeAsyncTaskTest(){

doSomeHeavyBackgroundTask(4000);

printLog();

//你会发现，当你像这样内部调用的时候，居然是同步执行的，不是异步的！！

}

@Async

public void doSomeHeavyBackgroundTask(int sleepTime) {

try {

Thread.sleep(sleepTime);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

public void printLog() {

System.out.println(" i print a log ");

}

}

另外一点就是不要重复的扫描，这也会导致异步无效，具体的可以看这个stackoveflow的spring-async-not-working Issue。

关于异常处理，难免在这个异步执行过程中有异常发生，对于这个问题，spring提供的解决方案如下,实现

AsyncUncaughtExceptionHandler接口。

public class MyAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {

@Override

public void handleUncaughtException(Throwable ex, Method method, Object... params) {

// handle exception

}

}

写好我们的异常处理后，我们需要配置一下，告诉spring，这个异常处理就是我们在运行异步任务时候，抛出错误时的异常终结者

@Configuration

@EnableAsync

public class AsyncConfig implements AsyncConfigurer {

@Bean

public AsyncTask asyncBean() {

return new AsyncTask();

}

@Override

public Executor getAsyncExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

executor.setCorePoolSize(7);

executor.setMaxPoolSize(42);

executor.setQueueCapacity(11);

executor.setThreadNamePrefix("MyExecutor-");

executor.initialize();

return executor;

}

@Override

public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

return new MyAsyncUncaughtExceptionHandler();

}

}

4、Quartz登场

处理这两个外，还有一个和spring整合的第三方库叫Quartz

看了下官网的使用简介，也是挺逗的，现在都习惯用maven，gradle之类来关系这些依赖了，他还叫人下载，也是不知为何，详情点击－>http://quartz-scheduler.org/documentation/quartz-2.2.x/quick-start

估计有可能是因为没再维护了的原因吧，看了下，最新版2.2居然是Sep, 2013更新的…

居然是停更的，不过Quartz作为一个企业级应用的任务调度框架，还是一个可以的候选项目的。

这里不铺开讲，有兴趣就去官网看下吧。整体用起来感觉是没有spring自己的后台任务方便，不过也可以接受，只需要简单的配置就可以使用了。

@Scheduled 和@Async的使用

如题，今天在知乎突然看到一份关于springboot自带调度器的问题思考，有这么一段内容“在使用@Scheduled注解时，如果不自己重新配置调度器，那么就会使用默认的，从而会导致一些调度执行上的问题”；联系到自己在程序中使用时没有关注到这个问题，因此仔细测试研究一番，最终了解了其中的一些关键思想。

首先，需要了解@Scheduled 和@Async这俩注解的区别：

@Scheduled 任务调度注解，主要用于配置定时任务；springboot默认的调度器线程池大小为 1。

@Async 任务异步执行注解，主要用于方法上，表示当前方法会使用新线程异步执行；springboot默认执行器线程池大小为100。

所以，如果在使用springboot定时器时，如果有多个定时任务时，在使用默认的调度器配置，就会出现排队现象，因为同时只能有一个任务在执行，这个时候当一个任务挂死，那后面的定时任务就不能有效执行了；

解决办法就是自定义调度器，有两种方式：

方法一：

@Bean

public TaskScheduler scheduledExecutorService() {

ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();

scheduler.setPoolSize(10);

scheduler.setThreadNamePrefix("scheduled-thread-");

//设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean

scheduler.setWaitForTasksToCompleteOnShutdown(true);

//设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住

scheduler.setAwaitTerminationSeconds(60);

//这里采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务

scheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

return scheduler;

}

方法二：

@Configuration

public class ScheduledConfig implements SchedulingConfigurer {

public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

taskRegistrar.setScheduler(setExecutor());

}

@Bean(destroyMethod="shutdown")

public Executor setExecutor(){

return Executors.newScheduledThreadPool(10); // 10个线程来处理。

}

}

上述自定义调度器的方式，会有一个问题：当有足够的空余线程时，多任务时并行执行，但是同一定时任务仍会同步执行（当定时任务的执行时间大于每次执行的时间间隔时即可发现）；

配合@Async 注解使用，这样在每次执行定时任务时就新开一个线程，异步非阻塞运行；同时使用这两个注解的效果，相当于@Scheduled仅仅负责调度，而@Async指定的exeyRsegbxNLkcutor负责任务执行，不再使用调度器中的执行器来执行任务（由实际测试结果来猜测的，并没有找到对应的源码逻辑，待后续补充）。

自定义执行器配置如下：

@Bean("taskExecutor")

public ThreadPoolTaskExecutor taskExecutor(){

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

executor.setCorePoolSize(corePoolSize);

executor.setMaxPoolSize(maxPoolSize);

executor.setQueueCapacity(queueCapacity);

executor.setKeepAliveSeconds(keepAliveTime);

executor.setThreadNamePrefix(threadNamePrefix);

// 线程池对拒绝任务的处理策略

executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

// 初始化

executor.initialize();

return executor;

}

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