服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - Spring之两种任务调度Scheduled和Async详解

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

2022-02-22 00:39slimer Java教程

这篇文章主要介绍了Spring之两种任务调度Scheduled和Async，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

1、Spring调度的两种方式

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

  • 调度任务，@Schedule
  • 异步任务，@Async

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

<task:annotation-driven/>当然，如果我们是基于java配置的，需要在配置哪里加多EnableScheduling和@EnableAsync 就像下面这样

?
1
2
3
4
5
@EnableScheduling
@EnableAsync
public class WebAppConfig {
   ....
｝

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

2、@Schedule

先看下@Schedule怎么调用再说

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public void AsyncTask(){
    @Async
    public void doSomeHeavyBackgroundTask(int sleepTime) {
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }    
     
    @Async
    public Future<String> 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());
    }
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@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调用的。

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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提供的解决方案如下,实现
?
1
2
3
4
5
6
7
AsyncUncaughtExceptionHandler接口。
public class MyAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // handle exception
    }
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@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定时器时，如果有多个定时任务时，在使用默认的调度器配置，就会出现排队现象，因为同时只能有一个任务在执行，这个时候当一个任务挂死，那后面的定时任务就不能有效执行了；

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

方法一：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@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;
  }

方法二：

?
1
2
3
4
5
6
7
8
9
10
11
@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指定的executor负责任务执行，不再使用调度器中的执行器来执行任务（由实际测试结果来猜测的，并没有找到对应的源码逻辑，待后续补充）。

自定义执行器配置如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@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;
 }

以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。

原文链接：https://www.cnblogs.com/slimer/p/6401394.html

  • spring
  • async
  • Scheduled

    • 延伸 · 阅读

    精彩推荐
    • Java教程简单实现Java web服务器

      简单实现Java web服务器

      这篇文章主要为大家详细介绍了简单实现Java web服务器的详细步骤，感兴趣的小伙伴们可以参考一下 ...

      风一样的码农2352020-05-19
    • Java教程java 如何实现多语言配置i18n

      java 如何实现多语言配置i18n

      这篇文章主要介绍了java 如何实现多语言配置i18n的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教...

      41摄氏度男9202021-11-05
    • Java教程SpringBoot项目中接口限流实现方案

      SpringBoot项目中接口限流实现方案

      本篇带给大家在SpringBoot项目中接口限流实现方案，一般有漏桶算法和令牌桶算法及计数器三种方式。希望对你有所帮助！...

      FastCoder5702021-03-31
    • Java教程springboot + JPA 配置双数据源实战

      springboot + JPA 配置双数据源实战

      这篇文章主要介绍了springboot + JPA 配置双数据源实战，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教...

      Frankenstein_6142021-12-27
    • Java教程Java锁之可重入锁介绍

      Java锁之可重入锁介绍

      这篇文章主要介绍了Java锁之可重入锁介绍,可重入锁,也叫做递归锁,指的是同一线程外层函数获得锁之后,内层递归函数仍然有获取该锁的代码,但不受影响...

      junjie2752019-12-04
    • Java教程java对double数组排序示例分享

      java对double数组排序示例分享

      这篇文章主要介绍了java对double数组排序示例，代码简单，下面我们直接上代码,需要的朋友可以参考下 ...

      java教程网3842019-11-12
    • Java教程Java多线程编程之使用Exchanger数据交换实例

      Java多线程编程之使用Exchanger数据交换实例

      这篇文章主要介绍了Java多线程编程之使用Exchanger数据交换实例,本文直接给出实例代码,需要的朋友可以参考下 ...

      junjie5712019-12-17
    • Java教程Maven本地jar引用的实现方法

      Maven本地jar引用的实现方法

      这篇文章主要介绍了Maven本地jar引用的实现方法的相关资料,希望通过本文能帮助到大家，实现这样的功能，需要的朋友可以参考下...

      回首凡尘不做仙6122021-01-21
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 2000 　 1433 　 401 　 330 　 htmlparser 　 选择排序法 　 随机抽取 　 内存卡 　 下载器 　 十六进制字符 　 响应 　 静态工厂 　 构造函数 　 swt 　 Overview 　 对象池模式 　 子线程 　 支票 　 金额大写转换 　 空心菱形 　 AspectJ 　 面向切面编程 　 方法名 　 网址信息 　 动态代理模式 　 线程安全 　 fixedDelay 　
    © 2019-2022 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图