玩轉SpringBoot之定時任務詳解

原文地址：https://www.cnblogs.com/mmzs/p/10161936.html

序言

使用SpringBoot創建定時任務非常簡單，目前主要有以下三種創建方式：

一、基於註解(@Scheduled)
二、基於接口（SchedulingConfigurer）前者相信大家都很熟悉，但是實際使用中我們往往想從數據庫中讀取指定時間來動態執行定時任務，這時候基於接口的定時任務就派上用場了。
三、基於註解設定多線程定時任務

一、靜態：基於註解

基於註解@Scheduled默認爲單線程，開啓多個任務時，任務的執行時機會受上一個任務執行時間的影響。

1、創建定時器

使用SpringBoot基於註解來創建定時任務非常簡單，只需幾行代碼便可完成。代碼如下：

@Configuration      //1.主要用於標記配置類，兼備Component的效果。
@EnableScheduling   // 2.開啓定時任務
public class SaticScheduleTask {
    //3.添加定時任務
    @Scheduled(cron = "0/5 * * * * ?")
    //或直接指定時間間隔，例如：5秒
    //@Scheduled(fixedRate=5000)
    private void configureTasks() {
        System.err.println("執行靜態定時任務時間: " + LocalDateTime.now());
    }
}

根據上面例子我自己寫的一個例子驗證好用

Cron表達式參數分別表示：

秒（0~59）例如0/5表示每5秒
分（0~59）
時（0~23）
日（0~31）的某天，需計算
月（0~11）
周幾（可填1-7 或 SUN/MON/TUE/WED/THU/FRI/SAT）

@Scheduled：除了支持靈活的參數表達式cron之外，還支持簡單的延時操作，例如 fixedDelay ，fixedRate 填寫相應的毫秒數即可。

2、啓動測試

啓動應用，可以看到控制檯打印出如下信息：

顯然，使用@Scheduled 註解很方便，但缺點是當我們調整了執行週期的時候，需要重啓應用才能生效，這多少有些不方便。爲了達到實時生效的效果，可以使用接口來完成定時任務。

二、動態：基於接口

基於接口（SchedulingConfigurer）

1、導入依賴包：

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>

    <dependencies>
        <dependency><!--添加Web依賴 -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency><!--添加MySql依賴 -->
             <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency><!--添加Mybatis依賴 配置mybatis的一些初始化的東西-->
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency><!-- 添加mybatis依賴 -->
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

2、添加數據庫記錄：

開啓本地數據庫mysql，隨便打開查詢窗口，然後執行腳本內容，如下：

DROP DATABASE IF EXISTS `socks`;
CREATE DATABASE `socks`;
USE `SOCKS`;
DROP TABLE IF EXISTS `cron`;
CREATE TABLE `cron`  (
  `cron_id` varchar(30) NOT NULL PRIMARY KEY,
  `cron` varchar(30) NOT NULL  
);
INSERT INTO `cron` VALUES ('1', '0/5 * * * * ?');

然後在項目中的application.yml 添加數據源：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/socks
    username: root
    password: 123456

3、創建定時器

數據庫準備好數據之後，我們編寫定時任務，注意這裏添加的是TriggerTask，目的是循環讀取我們在數據庫設置好的執行週期，以及執行相關定時任務的內容。
具體代碼如下：

@Configuration      //1.主要用於標記配置類，兼備Component的效果。
@EnableScheduling   // 2.開啓定時任務
public class DynamicScheduleTask implements SchedulingConfigurer {

    @Mapper
    public interface CronMapper {
        @Select("select cron from cron limit 1")
        public String getCron();
    }

    @Autowired      //注入mapper
    @SuppressWarnings("all")
    CronMapper cronMapper;

    /**
     * 執行定時任務.
     */
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

        taskRegistrar.addTriggerTask(
                //1.添加任務內容(Runnable)
                () -> System.out.println("執行動態定時任務: " + LocalDateTime.now().toLocalTime()),
                //2.設置執行週期(Trigger)
                triggerContext -> {
                    //2.1 從數據庫獲取執行週期
                    String cron = cronMapper.getCron();
                    //2.2 合法性校驗.
                    if (StringUtils.isEmpty(cron)) {
                        // Omitted Code ..
                    }
                    //2.3 返回執行週期(Date)
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );
    }

}

4、啓動測試

啓動應用後，查看控制檯，打印時間是我們預期的每10秒一次：

然後打開Navicat ，將執行週期修改爲每6秒執行一次，如圖：

查看控制檯，發現執行週期已經改變，並且不需要我們重啓應用，十分方便。如圖：

注意：如果在數據庫修改時格式出現錯誤，則定時任務會停止，即使重新修改正確；此時只能重新啓動項目才能恢復。

回到頂部

三、多線程定時任務

基於註解設定多線程定時任務

1、創建多線程定時任務

//@Component註解用於對那些比較中立的類進行註釋；
//相對與在持久層、業務層和控制層分別採用 @Repository、@Service 和 @Controller 對分層中的類進行註釋
@Component
@EnableScheduling   // 1.開啓定時任務
@EnableAsync        // 2.開啓多線程
public class MultithreadScheduleTask {

        @Async
        @Scheduled(fixedDelay = 1000)  //間隔1秒
        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 = 2000)
        public void second() {
            System.out.println("第二個定時任務開始 : " + LocalDateTime.now().toLocalTime() + "\r\n線程 : " + Thread.currentThread().getName());
            System.out.println();
        }
    }

注：這裏的@Async註解很關鍵

2、啓動測試

啓動應用後，查看控制檯：

從控制檯可以看出，第一個定時任務和第二個定時任務互不影響；

並且，由於開啓了多線程，第一個任務的執行時間也不受其本身執行時間的限制，所以需要注意可能會出現重複操作導致數據異常。

——————————————————————————————————————————————————————

Spring中@Async
1. 何爲異步調用？
- 同步調用：順序執行，需等待上一個任務執行完畢再執行下一個任務
- 異步調用：接收到指令就執行，無需等待，也不阻塞，繼續執行主調線程
2. 常規的異步調用處理方式
3. 如何在Spring中啓用@Async？
4. 基於@Async調用中的異常處理機制
5. @Async調用中的事務處理機制
- 示例：
6. 參考文章：

閱讀正文：

序言：Spring中@Async

根據Spring的文檔說明，默認採用的是單線程的模式的。所以在Java應用中，絕大多數情況下都是通過同步的方式來實現交互處理的。

那麼當多個任務的執行勢必會相互影響。例如，如果A任務執行時間比較長，那麼B任務必須等到A任務執行完畢後纔會啓動執行。又如在處理與第三方系統交互的時候，容易造成響應遲緩的情況，之前大部分都是使用多線程來完成此類任務，其實，在spring3.x之後，已經內置了@Async來完美解決這個問題。

1. 何爲異步調用？

在解釋之前，我們先來看二者的定義：

同步調用：順序執行，需等待上一個任務執行完畢再繼續執行下一個任務（串行執行）

就是整個處理過程順序執行，當各個過程都逐一執行完畢，並返回結果。

異步調用：接收到指令就執行，無需等待，（非阻塞併發執行）

則是隻是發送了調用的指令，調用者無需等待被調用的方法完全執行完畢；而是繼續執行下面的流程。

例如，在某個調用中，需要順序調用A,B,C三個過程方法：
如他們都是同步調用，則需要將他們都順序執行完畢之後，方算作過程執行完畢；若B爲一個異步的調用方法，則在執行完A之後，調用B，並不等待B完成，而是執行開始調用C，待C執行完畢之後，就意味着這個過程執行完畢了。

如圖所示：

2. 常規的異步調用處理方式

在Java中，一般在處理類似的場景之時，都是基於創建獨立的線程去完成相應的異步調用邏輯，通過主線程和不同的線程之間的執行流程，從而在啓動獨立的線程之後，主線程繼續執行而不會產生停滯等待的情況。或是使用TaskExecutor執行異步線程，參看http://www.cnblogs.com/wihainan/p/6098970.html

3. 如何在Spring中啓用@Async？

3.0、@Async介紹

在Spring中，基於@Async標註的方法，稱之爲異步方法；這些方法在執行的時候，將會在獨立的線程中被執行，調用者無需等待它的完成，即可繼續其他的操作。

3.1、啓用`@Async`註解

3.1.1、基於Java配置的啓用方式：

@Configuration  
@EnableAsync  
public class SpringAsyncConfig { ... }

3.1.2、基於SpringBoot配置的啓用方式：

@SpringBootApplication
@EnableAsync
public class SpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApplication.class, args);
    }
}

3.2、使用`@Async`註解，聲明方法爲異步調用

3.2.0、在無返回值方法上使用：

在方法上申明爲異步調用方法即可

    @Async //標註使用
    public void downloadFile() throws Exception { ... }

3.2.1、在有返回值方法上使用：

@Async  
public Future<String> asyncMethodWithReturnType() {  
    System.out.println("Execute method asynchronously - "  + Thread.currentThread().getName());  
    try {  
        Thread.sleep(5000);  
        return new AsyncResult<String>("hello world !!!!");  
    } catch (InterruptedException e) {  
        //  
    }  
   
    return null;  
}

以上示例可以發現，返回的數據類型爲Future類型，其爲一個接口。具體的結果類型爲AsyncResult,這個是需要注意的地方。

調用返回結果的異步方法示例:

public void testAsyncAnnotationForMethodsWithReturnType()  
   throws InterruptedException, ExecutionException {  
    System.out.println("Invoking an asynchronous method. "   + Thread.currentThread().getName());  
    Future<String> future = asyncAnnotationExample.asyncMethodWithReturnType();  
   
    while (true) {  ///這裏使用了循環判斷，等待獲取結果信息  
        if (future.isDone()) {  //判斷是否執行完畢  
            System.out.println("Result from asynchronous process - " + future.get());  
            break;  
        }  
        System.out.println("Continue doing something else. ");  
        Thread.sleep(1000);  
    }  
}

這些獲取異步方法的結果信息，是通過不停的檢查Future的狀態來獲取當前的異步方法是否執行完畢來實現的。

4. 基於@Async調用中的異常處理機制

在異步方法中，如果出現異常，對於調用者caller而言，是無法感知的。如果確實需要進行異常處理，則按照如下方法來進行處理：

自定義實現AsyncTaskExecutor的任務執行器
在這裏定義處理具體異常的邏輯和方式。
配置由自定義的TaskExecutor替代內置的任務執行器

示例步驟1，自定義的TaskExecutor

public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor {  
    private AsyncTaskExecutor executor;  
    public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) {  
        this.executor = executor;  
     }  
      ////用獨立的線程來包裝，@Async其本質就是如此  
    public void execute(Runnable task) {       
      executor.execute(createWrappedRunnable(task));  
    }  
    public void execute(Runnable task, long startTimeout) {  
        /用獨立的線程來包裝，@Async其本質就是如此  
       executor.execute(createWrappedRunnable(task), startTimeout);           
    }   
    public Future submit(Runnable task) { return executor.submit(createWrappedRunnable(task));  
       //用獨立的線程來包裝，@Async其本質就是如此。  
    }   
    public Future submit(final Callable task) {  
      //用獨立的線程來包裝，@Async其本質就是如此。  
       return executor.submit(createCallable(task));   
    }   
      
    private Callable createCallable(final Callable task) {   
        return new Callable() {   
            public T call() throws Exception {   
                 try {   
                     return task.call();   
                 } catch (Exception ex) {   
                     handle(ex);   
                     throw ex;   
                   }   
                 }   
        };   
    }  
  
    private Runnable createWrappedRunnable(final Runnable task) {   
         return new Runnable() {   
             public void run() {   
                 try {  
                     task.run();   
                  } catch (Exception ex) {   
                     handle(ex);   
                   }   
            }  
        };   
    }   
    private void handle(Exception ex) {  
      //具體的異常邏輯處理的地方  
      System.err.println("Error during @Async execution: " + ex);  
    }  
}

分析：可以發現其是實現了AsyncTaskExecutor, 用獨立的線程來執行具體的每個方法操作。在createCallable和createWrapperRunnable中，定義了異常的處理方式和機制。

handle()就是未來我們需要關注的異常處理的地方。
xml配置文件中的內容：

<task:annotation-driven executor="exceptionHandlingTaskExecutor" scheduler="defaultTaskScheduler" />  
<bean id="exceptionHandlingTaskExecutor" class="nl.jborsje.blog.examples.ExceptionHandlingAsyncTaskExecutor">  
    <constructor-arg ref="defaultTaskExecutor" />  
</bean>  
<task:executor id="defaultTaskExecutor" pool-size="5" />  
<task:scheduler id="defaultTaskScheduler" pool-size="1" />

也可以使用註解的形式將其配置註冊到bean中。

解釋：

5. @Async調用中的事務處理機制

在@Async標註的方法，同時也使用@Transactional進行標註；在其調用數據庫操作之時，將無法產生事務管理的控制，原因就在於其是基於異步處理的操作。

那該如何給這些操作添加事務管理呢？

可以將需要事務管理操作的方法放置到異步方法內部，在內部被調用的方法上添加@Transactional

示例：

方法A， 使用了@Async/@Transactional來標註，但是無法產生事務控制的目的。

方法B， 使用了@Async來標註，B中調用了C、D，C/D分別使用@Transactional做了標註，則可實現事務控制的目的。

brave_zhao

發佈了173 篇原創文章 · 獲贊 33 · 訪問量 38萬+

他的留言板關注

spring boot下定時任務的功能實現（轉載）

玩轉SpringBoot之定時任務詳解

序言

一、靜態：基於註解

二、動態：基於接口

三、多線程定時任務

序言：Spring中@Async

1. 何爲異步調用？

同步調用：順序執行，需等待上一個任務執行完畢再繼續執行下一個任務（串行執行）

異步調用：接收到指令就執行，無需等待，（非阻塞併發執行）

2. 常規的異步調用處理方式

3. 如何在Spring中啓用@Async？

3.0、@Async介紹

3.1、啓用`@Async`註解

3.2、使用`@Async`註解，聲明方法爲異步調用

4. 基於@Async調用中的異常處理機制

5. @Async調用中的事務處理機制

示例：

oracle中的關聯更新語句示例

oracle編寫自定義函數例子

自己整理的財務知識（財務比率）（英文不標準是爲了自己建立自定義字段而已）

springboot RestController中獲取 Cookie方法

impala建表語句原創,impala建立kudu表

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

spring boot下定時任務的功能實現（轉載）

序言

一、靜態：基於註解

二、動態：基於接口

三、多線程定時任務

序言：Spring中@Async

1. 何爲異步調用？

同步調用：順序執行，需等待上一個任務執行完畢再繼續執行下一個任務（串行執行）

異步調用：接收到指令就執行，無需等待，（非阻塞併發執行）

2. 常規的異步調用處理方式

3. 如何在Spring中啓用@Async？

3.0、@Async介紹

3.1、啓用@Async註解

3.2、使用@Async註解，聲明方法爲異步調用

4. 基於@Async調用中的異常處理機制

5. @Async調用中的事務處理機制

示例：

3.1、啓用`@Async`註解

3.2、使用`@Async`註解，聲明方法爲異步調用