springboot：非同步註解@Async的前世今生

北漂程式設計師發表於2022-04-30

在前邊的文章中，和小夥伴一起認識了非同步執行的好處，以及如何進行非同步開發，對，就是使用@Async註解，在使用非同步註解@Async的過程中也存在一些坑，不過通過正確的開啟方式也可以很好的避免，今天想和大家分享下@Async的原理，開始前先溫習下之前的文章哦，

springboot：非同步呼叫@Async

springboot：使用非同步註解@Async獲取執行結果的坑

springboot：巢狀使用非同步註解@Async還會非同步執行嗎

一、引言

在前邊說到在使用@Async的時候，在一個類中兩個@Async的方法巢狀使用會導致非同步失敗，下面把場景重現下，

AsyncContoller.java

package com.example.myDemo.controller;

import com.example.myDemo.service.AsyncService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.concurrent.ExecutionException;

@Controller
public class AsyncController {
    @Autowired
    private AsyncService asyncService;
    @GetMapping("/aysnc")
    @ResponseBody
    public String asyncMethod(){
        try {
            Long start=System.currentTimeMillis();
            //呼叫method3方法，該方法中巢狀了一個非同步方法
            String str3=asyncService.method3().get();
            Long end=System.currentTimeMillis();
            System.out.println("執行時長:"+(end-start));
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
        return "hello @Async";
    }
}

下面是method3方法

package com.example.myDemo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import java.util.concurrent.Future;

@Service
@Async
public class AsyncService {
    /**
     * 第一個非同步方法，睡眠10s返回字串
     *
     * @return
     */
    public Future<String> method() {
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult("I am method");
    }

    /**
     * 第三個非同步方法，在該非同步方法中呼叫了另外一個非同步方法
     * @return
     */
    public Future<String> method3(){
        try{
            //睡眠10s
            Thread.sleep(10*1000);
            System.out.println(this);
            //method方法也是睡眠10s
            this.method();

        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<>("two async method");
    }
}

上面便是method3方法，以及巢狀在method3方法中的method方法，這兩個方法體上均沒有標註@Async，只是在這個類上使用了@Async註解，那麼該類中的所有方法都是非同步的。

執行結果如下，

2022-04-30 15:29:47.711  INFO 16836 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 4 ms
com.example.myDemo.service.AsyncService@7e316231
執行時長:20028

從上面可以看到整個方法的執行時長是20多秒，那麼就說明這種同一個類中的巢狀呼叫，@Async是失效的。

二、解決方式

1、把巢狀方法抽到另一個類中

這種方式就是把巢狀的非同步方法method抽取到另外一個類中，下面我們來看下，

OtherService.java

package com.example.myDemo.service;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import java.util.concurrent.Future;

@Service
@Async
public class OtherAsyncService {
    public Future<String> method() {
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult("I am method");
    }
}

那麼AsyncService.java則變成下面的樣子

package com.example.myDemo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;

@Service
@Async
public class AsyncService {
    //注入OtherService
    @Autowired
    private OtherAsyncService otherAsyncService;
    
    /**
     * 第三個非同步方法，在該非同步方法中呼叫了另外一個非同步方法
     * @return
     */
    public Future<String> method3(){
        try{
            Thread.sleep(10*1000);
            System.out.println(this);
           //呼叫OtherAsyncService的method方法
            otherAsyncService.method();

        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<>("two async method");
    }
}

下面看執行的結果，

2022-04-30 15:44:18.914  INFO 16768 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
com.example.myDemo.service.AsyncService@689927ef
執行時長:10016

執行時長10s多點，符合預期。

2、自己注入自己

這種方式很有意思，我斗膽給它取名為“自己注入自己”，在AsyncService類中注入一個AsyncService的例項，如下

package com.example.myDemo.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;

@Service
@Async
public class AsyncService {
   //這裡注入的是AsyncService的例項
    @Lazy
    @Autowired
    private AsyncService otherAsyncService;
    /**
     * 第一個非同步方法，睡眠10s返回字串
     *
     * @return
     */
    public Future<String> method() {
        try {
            Thread.sleep(10 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult("I am method");
    }
    /**
     * 第三個非同步方法，在該非同步方法中呼叫了另外一個非同步方法
     * @return
     */
    public Future<String> method3(){
        try{
            Thread.sleep(10*1000);
            System.out.println(this);
            otherAsyncService.method();

        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<>("two async method");
    }
}

小夥伴們注意，我是在AsyncService類中又注入了一個AsyncService的例項，在method3方法中呼叫的是AsyncSerevice的方法method，要區別於下面的呼叫方式

 this.method();

下面看下執行結果，

2022-04-30 15:55:30.635  INFO 9788 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 5 ms
com.example.myDemo.service.AsyncService@2ac186f8
執行時長:10015

好了，我們看到執行時長為10s多點，也就是說非同步是生效的，在這種方式中要注意注入的物件必須新增@Lazy註解，否則啟動會報錯哦。