一文搞懂SpringBoot如何利用@Async實現(xiàn)異步調(diào)用

更新時間：2022年09月08日 14:38:43 作者：老顧聊技術(shù)

異步調(diào)用幾乎是處理高并發(fā)，解決性能問題常用的手段，如何開啟異步調(diào)用？SpringBoot中提供了非常簡單的方式，就是一個注解@Async。今天我們重新認識一下@Async,以及注意事項

前言

簡單使用

新建三個作業(yè)任務(wù)：

@Service
public class TaskDemo {
    private static Logger logger = LoggerFactory.getLogger(TaskDemo.class);
    public void execute1() {
        logger.info("處理耗時任務(wù)1......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)1......結(jié)束");
    }
    public void execute2() {
        logger.info("處理耗時任務(wù)2......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)2......結(jié)束");
    }
    public void execute3() {
        logger.info("處理耗時任務(wù)3......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)3......結(jié)束");
    }
}

測試代碼：

@RestController
public class TaskController {
    @Autowired
    private TaskDemo taskDemo;

    @GetMapping("/task/test")
    public String testTask() {
        taskDemo.execute1();
        taskDemo.execute2();
        taskDemo.execute3();
        return "ok";
    }
}

執(zhí)行后我們可以發(fā)現(xiàn)，上面的代碼是同一個線程的同步執(zhí)行，整體耗時9秒才完成。

異步處理

springboot的異步，是非常簡單的，加2個注解即可

@Service
public class TaskDemo {

    private static Logger logger = LoggerFactory.getLogger(TaskDemo.class);

    @Async
    public void execute1() {
        logger.info("處理耗時任務(wù)1......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)1......結(jié)束");
    }

    @Async
    public void execute2() {
        logger.info("處理耗時任務(wù)2......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)2......結(jié)束");
    }

    @Async
    public void execute3() {
        logger.info("處理耗時任務(wù)3......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)3......結(jié)束");
    }

}

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

增加了@Async和@EnableAsync兩個注解

從執(zhí)行結(jié)果發(fā)現(xiàn)，整個流程用了3秒，以及用了3個線程執(zhí)行。完成了異步調(diào)用

異步回調(diào)

有些場景我們需要知道異步處理的任務(wù)什么時候完成，需要做額外的業(yè)務(wù)處理。如：我們需要在3個任務(wù)都完成后，提示一下給用戶

@Service
public class TaskDemo {

    private static Logger logger = LoggerFactory.getLogger(TaskDemo.class);

    @Async
    public Future<String> execute1() {
        logger.info("處理耗時任務(wù)1......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)1......結(jié)束");

        return new AsyncResult<>("任務(wù)1 ok");
    }

    @Async
    public Future<String> execute2() {
        logger.info("處理耗時任務(wù)2......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)2......結(jié)束");

        return new AsyncResult<>("任務(wù)2 ok");
    }

    @Async
    public Future<String> execute3() {
        logger.info("處理耗時任務(wù)3......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)3......結(jié)束");

        return new AsyncResult<>("任務(wù)3 ok");
    }
}

@RestController
public class TaskController {

    private static Logger logger = LoggerFactory.getLogger(TaskController.class);

    @Autowired
    private TaskDemo taskDemo;

    @GetMapping("/task/test")
    public String testTask() throws InterruptedException {
        Future<String> task1 = taskDemo.execute1();
        Future<String> task2 = taskDemo.execute2();
        Future<String> task3 = taskDemo.execute3();

        while (true){
            if (task1.isDone() && task2.isDone() && task3.isDone()){
                break;
            }
            TimeUnit.SECONDS.sleep(1);
        }

        logger.info(">>>>>>3個任務(wù)都處理完成");
        return "ok";
    }
}

執(zhí)行結(jié)果發(fā)現(xiàn)，在請求線程里面給用戶提示了3個任務(wù)都處理完成了。

這段代碼主要改變了什么：

1、把具體任務(wù)返回類型改為了Future類型對象

2、在調(diào)用任務(wù)時，循環(huán)判斷任務(wù)是否處理完

自定義線程池

說到異步處理，一定要考慮到線程池，什么是線程池，小伙伴可自行網(wǎng)補。@Async的線程池定義比較方便，直接上代碼：

@Configuration
public class ThreadPoolConfig {

    @Bean(name = "taskPool01Executor")
    public ThreadPoolTaskExecutor getTaskPool01Executor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //核心線程數(shù)
        taskExecutor.setCorePoolSize(10);
        //線程池維護線程的最大數(shù)量,只有在緩沖隊列滿了之后才會申請超過核心線程數(shù)的線程
        taskExecutor.setMaxPoolSize(100);
        //緩存隊列
        taskExecutor.setQueueCapacity(50);
        //許的空閑時間,當超過了核心線程出之外的線程在空閑時間到達之后會被銷毀
        taskExecutor.setKeepAliveSeconds(200);
        //異步方法內(nèi)部線程名稱
        taskExecutor.setThreadNamePrefix("TaskPool-01-");
        /**
         * 當線程池的任務(wù)緩存隊列已滿并且線程池中的線程數(shù)目達到maximumPoolSize，如果還有任務(wù)到來就會采取任務(wù)拒絕策略
         * 通常有以下四種策略：
         * ThreadPoolExecutor.AbortPolicy:丟棄任務(wù)并拋出RejectedExecutionException異常。
         * ThreadPoolExecutor.DiscardPolicy：也是丟棄任務(wù)，但是不拋出異常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務(wù)，然后重新嘗試執(zhí)行任務(wù)（重復(fù)此過程）
         * ThreadPoolExecutor.CallerRunsPolicy：重試添加當前的任務(wù)，自動重復(fù)調(diào)用 execute() 方法，直到成功
         */
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);

        taskExecutor.initialize();

        return taskExecutor;
    }

    @Bean(name = "taskPool02Executor")
    public ThreadPoolTaskExecutor getTaskPool02Executor() {

        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //核心線程數(shù)
        taskExecutor.setCorePoolSize(10);
        //線程池維護線程的最大數(shù)量,只有在緩沖隊列滿了之后才會申請超過核心線程數(shù)的線程
        taskExecutor.setMaxPoolSize(100);
        //緩存隊列
        taskExecutor.setQueueCapacity(50);
        //許的空閑時間,當超過了核心線程出之外的線程在空閑時間到達之后會被銷毀
        taskExecutor.setKeepAliveSeconds(200);
        //異步方法內(nèi)部線程名稱
        taskExecutor.setThreadNamePrefix("TaskPool-02-");
        /**
         * 當線程池的任務(wù)緩存隊列已滿并且線程池中的線程數(shù)目達到maximumPoolSize，如果還有任務(wù)到來就會采取任務(wù)拒絕策略
         * 通常有以下四種策略：
         * ThreadPoolExecutor.AbortPolicy:丟棄任務(wù)并拋出RejectedExecutionException異常。
         * ThreadPoolExecutor.DiscardPolicy：也是丟棄任務(wù)，但是不拋出異常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列最前面的任務(wù)，然后重新嘗試執(zhí)行任務(wù)（重復(fù)此過程）
         * ThreadPoolExecutor.CallerRunsPolicy：重試添加當前的任務(wù)，自動重復(fù)調(diào)用 execute() 方法，直到成功
         */
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);

        taskExecutor.initialize();

        return taskExecutor;
    }

}

定義了2個線程池Bean

@Service
public class TaskDemo {

    private static Logger logger = LoggerFactory.getLogger(TaskDemo.class);

    @Async("taskPool01Executor")
    public Future<String> execute1() {
        logger.info("處理耗時任務(wù)1......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)1......結(jié)束");

        return new AsyncResult<>("任務(wù)1 ok");
    }

    @Async("taskPool01Executor")
    public Future<String> execute2() {
        logger.info("處理耗時任務(wù)2......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)2......結(jié)束");

        return new AsyncResult<>("任務(wù)2 ok");
    }

    @Async("taskPool02Executor")
    public Future<String> execute3() {
        logger.info("處理耗時任務(wù)3......開始");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        logger.info("處理耗時任務(wù)3......結(jié)束");

        return new AsyncResult<>("任務(wù)3 ok");
    }

}

@Async(“線程池名稱”)，指定value使用自己定義的線程池：

執(zhí)行結(jié)果利用了線程池。

注意事項（一定注意）

在使用@Async注解時，很多小伙伴都會發(fā)現(xiàn)異步使用失敗。主要原因是異步方法的定義出了問題。

1、異步方法不能使用static修飾

2、異步類沒有使用@Component注解（或其他注解）導(dǎo)致spring無法掃描到異步類

3、異步方法和調(diào)用異步方法的方法不能在同一個類

4、類中需要使用@Autowired或@Resource等注解自動注入，不能自己手動new對象

5、如果使用SpringBoot框架必須在啟動類中增加@EnableAsync注解?

到此這篇關(guān)于一文搞懂SpringBoot如何利用@Async實現(xiàn)異步調(diào)用的文章就介紹到這了,更多相關(guān)SpringBoot @Async異步調(diào)用內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: