springboot和spring使用@Async注意事项

1：SpringBoot使用@Async注解

启动类上使用@EnableAsync注解

@SpringBootApplication
@EnableAsync
public class MainApplication {

    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}
1
2
3
4
5
6
7
8

2：在方法上加上@Async注解

异步方法所在的类必须注入容器中才能生效@Async

@Component
public class AsyncTask {
 
    @Async
    public void taskOne() throws Exception {
        // do someting
    }
 
    @Async
    public void taskTwo() throws Exception {
        // do someting
    }
 
    @Async
    public void taskThree() throws Exception {
        // do someting
    }
 
}

-----------------------------------------------------------------------------------

//调用方法测试
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@EnableAsync
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncTask asyncTask;

    @Test
    public void runAsync() throws Exception {
        long start = System.currentTimeMillis();
        asyncTask.taskOne();
        asyncTask.taskTwo();
        asyncTask.taskThere();
        
    }
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

此时可以反复执行单元测试，您可能会遇到各种不同的结果，比如：
1:没有任何任务相关的输出
2:有部分任务相关的输出
3:乱序的任务相关的输出
原因是TaskOne、TaskTwo、TaskThree三个函数的时候已经是异步执行了。主程序在异步调用之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就自动结束了，导致了不完整或是没有输出任务相关内容的情况。
可通过异步回调的方式解决

3：异步回调

@Component
public class AsyncTask {
 
    @Async
    public Future<String> taskOne() throws Exception {
        // do someting
        return new AsyncResult<>("任务一完成");
    }
 
    @Async
    public Future<String> taskTwo() throws Exception {
        // do someting
        return new AsyncResult<>("任务二完成");
    }
 
    @Async
    public Future<String> taskThree() throws Exception {
        // do someting
        return new AsyncResult<>("任务三完成");
    }
 
}

-----------------------------------------------------------------------------------

//调用方法测试
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@EnableAsync
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncTask asyncTask;

    @Test
    public void runAsync() throws Exception {
   		long start = System.currentTimeMillis();
        Future<String> task1 = asyncTask.taskOne();
        Future<String> task2 = asyncTask.taskTwo();
        Future<String> task3 = asyncTask.taskThere();
        while(true) {
        	if(task1.isDone() && task2.isDone() && task3.isDone()) {
            // 三个任务都调用完成，退出循环等待
            break;
        	}
        Thread.sleep(1000);
    	}
    	long end = System.currentTimeMillis();
    	log.info(”三个任务都调用完成耗时：“ + (end - start) + "毫秒");
    }
}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

4：导致@Async异步失效的情况

1：注解@Async方法使用static修饰会失效（异步的方法上加了static就不走AOP了）
2：调用方法和异步方法在同一个类中（当异步方法和调用方法在同一个类中时，是没办法通过Ioc里的bean来执行异步方法的，从而变成同步方法。因为@Async是基于Aop思想实现的）
3：注解@Async的方法不是public方法
4：spring无法扫描到异步类,没加注解@Async或@EnableAsync注解
5：类中需要使用@Autowired或@Resource等注解自动注入,不能自己手动new对象

5：@Async使用建议

• 异步执行的建议单独开启一个类实现，或者从容器中直接获取到该代理类后执行，异步代码写到别的地方，不要和Controller注解同时使用，正常的控制器不生成代理类
• 异步的方法上不要加static，加了static就不走AOP了

6：@Async+自定义线程池实现异步任务

如果不自定义异步方法的线程池默认使用SimpleAsyncTaskExecutor线程池。
SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。并发大的时候会产生严重的性能问题。
Spring也更加推荐我们开发者使用ThreadPoolTaskExecutor类来创建线程池

@Configuration
public class ExecutorAsyncConfig {
    
    @Bean(name = "newAsyncExecutor")
    public Executor newAsync() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //设置核心线程数
        taskExecutor.setCorePoolSize(10);
        // 线程池维护线程的最大数量，只有在缓冲队列满了以后才会申请超过核心线程数的线程
        taskExecutor.setMaxPoolSize(100);
        //缓存队列
        taskExecutor.setQueueCapacity(50);
        //允许的空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
        taskExecutor.setKeepAliveSeconds(200);
        //异步方法内部线程名称
        taskExecutor.setThreadNamePrefix("my-AsyncExecutor-");
        //拒绝策略
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}

-----------------------------------------------------------------------------------

//任务1和任务2配置走我们自定义的线程池，任务3还是走默认线程池
@Component
public class AsyncTask {
 
    @Async("newAsyncExecutor")
    public Future<String> taskOne() throws Exception {
        // do someting
        return new AsyncResult<>("任务一完成");
    }
 
    @Async("newAsyncExecutor")
    public Future<String> taskTwo() throws Exception {
        // do someting
        return new AsyncResult<>("任务二完成");
    }
 
    @Async
    public Future<String> taskThree() throws Exception {
        // do someting
        return new AsyncResult<>("任务三完成");
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

7：Spring 中 @Async 用法

spring基于Java注解的启用方式,在配置类上注入@EnableAsync，springboot是在启动类上@EnableAsync

@EnableAsync
@Configuration
public class ExecutorAsyncConfig {
    
    @Bean(name = "newAsyncExecutor")
    public Executor newAsync() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //设置核心线程数
        taskExecutor.setCorePoolSize(10);
        // 线程池维护线程的最大数量，只有在缓冲队列满了以后才会申请超过核心线程数的线程
        taskExecutor.setMaxPoolSize(100);
        //缓存队列
        taskExecutor.setQueueCapacity(50);
        //允许的空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
        taskExecutor.setKeepAliveSeconds(200);
        //异步方法内部线程名称
        taskExecutor.setThreadNamePrefix("my-AsyncExecutor-");
        //拒绝策略
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

8：CompletableFuture实现异步任务

推荐这种方式来实现异步,它不需要在启动类上加@EnableAsync注解，也不需要在方法上加@Async注解,它实现更加优雅，而且CompletableFuture功能更加强大
CompletableFuture的runAsync()方法没有返回值，需要有返回值的可使用supplyAsync()方法

@Component
public class NoAsyncTask {
 
    public Future<String> taskOne() throws Exception {
        // do someting
        return new AsyncResult<>("任务一完成");
    }
 
    public Future<String> taskTwo() throws Exception {
        // do someting
        return new AsyncResult<>("任务二完成");
    }
 
 
    public Future<String> taskThree() throws Exception {
        // do someting
        return new AsyncResult<>("任务三完成");
    }
 
}


-----------------------------------------------------------------------------------

//runAsync()方法没有返回值，需要有返回值的可使用supplyAsync()方法
@Slf4j
@RunWith(SpringJUnit4ClassRunner.class)
@EnableAsync
@SpringBootTest
public class AsyncTest {

    @Autowired
    private NoAsyncTask noasyncTask;

    @Test
    public void runAsync() throws Exception {
   		long start = System.currentTimeMillis();
   		CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
            //任务1
            noasyncTask.taskOne();
        });
        CompletableFuture<Void> cp2 = CompletableFuture.runAsync(() -> {
            //任务2
            noasyncTask.taskTwo();
        });
        CompletableFuture<String> cp3 = CompletableFuture.supplyAsync(() -> {
            //任务3
            String result3 = null;
            try {
                result3 = noasyncTask.taskThere().get();

            } catch (Exception e) {
                e.printStackTrace();
            }
            return result3 ;
        });
        //get方法是一个阻塞式等待的方法，也即get方法会等待异步任务的完成
        cp1.get();
        cp2.get();
        cp3.get();
    	long end = System.currentTimeMillis();
    	log.info(”三个任务都调用完成耗时：“ + (end - start) + "毫秒");
    }
}  


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66