Java开启异步的两种方式

二、Java开启异步的两种方式

1、注解开启：@Async

1.1、配置异步的线程池

• 必须配置异步线程池，否则异步不会生效。
  
• @EnableAsync 注解：指定异步线程池。不指定默认使用：SimpleAsyncTaskExecutor线程池
  
• SimpleAsyncTaskExecutor是一个最简单的线程池，它没有任何的线程相关参数配置，它会为每个任务创建一个新的线程来执行，因此不建议在生产环境中使用。
  
• 配置线程池见：https://www.cnblogs.com/kakarotto-chen/p/17428432.html
  

1. package com.cc.md.config;
3. import org.springframework.context.annotation.Bean;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.scheduling.annotation.EnableAsync;
6. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
8. import java.util.concurrent.ThreadPoolExecutor;
10. /** IO型的线程池
11. * @author CC
12. * @since 2023/5/23 0023
13. */
14. @Configuration
15. @EnableAsync
16. public class IoThreadPool {
18.     public static final int THREAD_SIZE = 2 * (Runtime.getRuntime().availableProcessors());
19.    
20.     public static final int QUEUE_SIZE = 1000;
22.     @Bean(name = "myIoThreadPool")
23.     public ThreadPoolTaskExecutor threadPoolExecutor(){
24.         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
25.         executor.setCorePoolSize(THREAD_SIZE);
26.         executor.setMaxPoolSize(THREAD_SIZE);
27.         executor.setQueueCapacity(QUEUE_SIZE);
28.         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
29.         executor.setKeepAliveSeconds(60);
30.         executor.setAllowCoreThreadTimeOut(true);
31.         executor.setAwaitTerminationSeconds(300);
32.         executor.setWaitForTasksToCompleteOnShutdown(true);
33.         executor.setThreadNamePrefix("myIo-Th-Pool-");
34.         executor.initialize();
35.         return executor;
36.     }
37. }

复制代码

1.2、异步方法

• 异步方法必须写在另一个类中，否则不生效
  
• @Async可以打在类上、也可以打在方法上
  

1.     1 @Async：类上，说明整个类中的方法都是异步。必须写我们自己配置的线程池 —— ("myIoThreadPool")
2.     2 @Async：方法上，说明这个方法是异步。不用写我们自己配置的线程池

复制代码

• 异步接口+实现类
  

接口

1. package com.cc.md.service;
3. /**
4. * @author CC
5. * @since 2023/5/24 0024
6. */
7. public interface IAsyncService {
9.     /** 异步方法1
10.      * @since 2023/5/24 0024
11.      * @author CC
12.      **/
13.     void async1();
15.     /** 异步方法2
16.      * @since 2023/5/24 0024
17.      * @author CC
18.      **/
19.     void async2();
21. }

复制代码

实现类

1. package com.cc.md.service.impl;
3. import com.cc.md.service.IAsyncService;
4. import org.slf4j.Logger;
5. import org.slf4j.LoggerFactory;
6. import org.springframework.scheduling.annotation.Async;
7. import org.springframework.stereotype.Service;
9. /** 1 @Async：类上，说明整个类中的方法都是异步。必须写我们自己配置的线程池 —— ("myIoThreadPool")
10. *  2 @Async：方法上，说明这个方法是异步。不用写我们自己配置的线程池
11. * @author CC
12. * @since 2023/5/24 0024
13. */
14. @Service
15. @Async("myIoThreadPool")
16. public class AsyncServiceImpl implements IAsyncService {
18.     private static final Logger log = LoggerFactory.getLogger(AsyncServiceImpl.class);
20.     //类上写了@Async，这里就可以不写了。
21.     //可以不写 ("myIoThreadPool")。因为在IoThreadPool中开启了异步，说明异步用的就是我们配置的io线程池
22.     //如果类上面打了 @Async ，这里必须写：("myIoThreadPool")
23.     @Override
24.     //@Async
25.     public void async1(){
26.         //模仿io流耗时
27.         try {
28.             Thread.sleep(5000);
29.         } catch (InterruptedException e) {
30.             throw new RuntimeException(e);
31.         }
32.         log.info("打印：{}", "异步方法1111！");
33.     }
35.     //@Async在类上面，说明这个方法也是异步方法。如果不打，无法开启异步。
36.     @Override
37.     public void async2(){
38.         //模仿io流耗时
39.         try {
40.             Thread.sleep(5000);
41.         } catch (InterruptedException e) {
42.             throw new RuntimeException(e);
43.         }
44.         log.info("打印：{}", "异步方法2222！");
45.     }
46. }

复制代码

1.3、测试

1.     @Resource
2.     private IAsyncService asyncService;
3.    
4.     //开启异步1 —— @Async
5.     @Test
6.     public void test03() throws Exception {
7.         log.info("打印：{}", "异步测试的-主方法1");
8.         asyncService.async1();
9.         asyncService.async2();
10.         //不会等待异步方法执行，直接返回前端数据
11.         log.info("打印：{}", "异步测试的-主方法2");
12.     }

复制代码

结果：

2、CompletableFuture的方式

使用：

1.     @Resource(name = "myIoThreadPool")
2.     private ThreadPoolTaskExecutor myIoThreadPool;
3.    
4.     //开启异步2 —— CompletableFuture.runAsync()
5.     @Test
6.     public void test04() throws Exception {
7.         log.info("打印：{}", "异步测试的-主方法1");
8.         CompletableFuture.runAsync(() -> {
9.             log.info("打印：{}", "异步方法1！");
10.             //异步执行的代码，也可以是方法，该方法不用单独写到其他类中。
11.             this.async2("异步方法1！-end");
12.         }, myIoThreadPool);
13.         //不会等待异步方法执行，直接返回前端数据
14.         log.info("打印：{}", "异步测试的-主方法2");
15.     }
17.     //异步需要执行的方法，可以写在同一个类中。
18.     private void async2(String msg) {
19.         //模仿io流耗时
20.         try {
21.             Thread.sleep(5000);
22.         } catch (InterruptedException e) {
23.             throw new RuntimeException(e);
24.         }
25.         log.info("打印：{}", msg);
26.     }

复制代码

结果：

• 后续CompletableFuture的使用见：《Java的CompletableFuture，Java的多线程开发》
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！