任意一个任务有异常，都不会进入applyToEitherAsync方法

3、@Async

基于@Async标注的方法，称之为异步方法；这些方法将在执行的时候，将会在独立的线程中被执行，调用者无需等待它的完成，即可继续其他的操作

启用@Async注解

package com.yzm.thread.async;

import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

@Configuration
@EnableAsync // 开启异步调用功能，即使@Async注解生效
@Slf4j
public class AsyncConfig implements AsyncConfigurer {

    @Bean(name = "default_async_pool", destroyMethod = "shutdown")
    public ThreadPoolTaskExecutor defaultAsyncPool() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置线程池前缀：方便排查
        executor.setThreadNamePrefix("default-async-");
        // 设置线程池的大小
        executor.setCorePoolSize(10);
        // 设置线程池的最大值
        executor.setMaxPoolSize(15);
        // 设置线程池的队列大小
        executor.setQueueCapacity(250);
        // 设置线程最大空闲时间，单位：秒
        executor.setKeepAliveSeconds(3000);
        // 饱和策略
        // AbortPolicy:直接抛出java.util.concurrent.RejectedExecutionException异常
        // CallerRunsPolicy:若已达到待处理队列长度，将由主线程直接处理请求
        // DiscardOldestPolicy:抛弃旧的任务；会导致被丢弃的任务无法再次被执行
        // DiscardPolicy:抛弃当前任务；会导致被丢弃的任务无法再次被执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        return executor;
    }

    @Bean(name = "another_async_pool", destroyMethod = "shutdown")
    public ThreadPoolTaskExecutor anotherAsyncPool() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setThreadNamePrefix("another-task-");
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(6);
        executor.setQueueCapacity(5);
        executor.setKeepAliveSeconds(10);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
        return executor;
    }

    /**
     * 自定义异步线程池，若不重写，则使用默认的
     */
    @Override
    public Executor getAsyncExecutor() {
        return defaultAsyncPool();
    }

    /**
     * 1.无参无返回值方法
     * 2.有参无返回值方法
     * 返回值为void的， 通过IllegalArgumentException异常, AsyncUncaughtExceptionHandler处理异常
     * 3.有参有返回值方法
     * 返回值是Future，不会被AsyncUncaughtExceptionHandler处理，需要我们在方法中捕获异常并处理
     * 或者在调用方在调用Future.get时捕获异常进行处理
     */
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        System.out.println("正在处理无返回值的@Async异步调用方法");
        return (throwable, method, objects) -> {
            log.info("Exception message - " + throwable.getMessage());
            log.info("Method name - " + method.getName());
            for (Object param : objects) {
                log.info("Parameter value - " + param);
            }
        };
    }

}


package com.yzm.thread.async;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

import java.util.concurrent.Future;

@Slf4j
@Component
public class AsyncService {

    /**
     * 1.无参无返回值方法
     * 最简单的异步调用，返回值为void
     */
    @Async
    public void async() {
        log.info("无参无返回值方法，通过观察线程名称以便查看效果");
//        int a = 1 / 0;
    }

    /**
     * 2.有参无返回值方法
     * 指定线程池
     *
     * @param i 传入参数
     */
    @Async("another_async_pool")
    public void async(int i) {
        log.info("有参无返回值方法, 参数={}", i);
    }

    /**
     * 3.有参有返回值方法
     *
     * @param i 传入参数
     * @return Future
     */
    @Async
    public Future asyncReturn(int i) throws InterruptedException {
        log.info("有参有返回值方法, 参数={}", i);
//        int a = 1 / 0;
        Thread.sleep(100);
        return new AsyncResult("success:" + i);
    }

    /**
     * @Async  必须不同类间调用：
     */
    public void D() {
        log.info("在同类下调用 @Async 方法是同步执行的");
        async();
    }
}
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

调用无参无返回值的异步方法

@Component
public class AsyncDemo {

    private final AsyncService asyncService;

    public AsyncDemo(AsyncService asyncService) {
        this.asyncService = asyncService;
    }

    @PostConstruct
    public void demo() {
        asyncA();
    }

    public void asyncA() {
        asyncService.async();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

调用有参无返回值的异步方法并指定线程池

AsyncService类

    /**
     * 2.有参无返回值方法
     * 指定线程池
     *
     * @param i 传入参数
     */
    @Async("another_async_pool")
    public void async(int i) {
        log.info("有参无返回值方法, 参数={}", i);
    }
1
2
3
4
5
6
7
8
9
10

AsyncDemo类

    @PostConstruct
    public void demo() {
//        asyncA();
        asyncB(1);
    }

    public void asyncA() {
        asyncService.async();
    }

    public void asyncB(int i) {
        asyncService.async(i);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13

调用有参有返回值的异步方法

    public void asyncC(int i) {
        try {
            Future future = asyncService.asyncReturn(i);
            // 这里使用了循环判断，等待获取结果信息
            while (true) {
                // 判断是否执行完毕
                if (future.isDone()) {
                    System.out.println("执行完毕，结果为：" + future.get());
                    break;
                }
                System.out.println("还未执行完毕，请稍等。。。");
                Thread.sleep(1000);
            }
        } catch (InterruptedException | ExecutionException e) {
            System.out.println("异步调用失败");
            e.printStackTrace();
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

调用方法内部调用一个异步方法是不行的，仍是同步调用

AsyncService类

    /**
     * @Async  必须不同类间调用：
     */
    public void D() {
        log.info("在同类下调用 @Async 方法是同步执行的");
        // 调用本类的异步方法
        async();
    }
1
2
3
4
5
6
7
8

AsyncDemo类

	public void asyncD() {
        asyncService.D();
    }
1
2
3

异常处理

AsyncConfig类

	// 可处理无返回值的异步方法异常
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        System.out.println("正在处理无返回值的@Async异步调用方法");
        return (throwable, method, objects) -> {
            log.info("Exception message - " + throwable.getMessage());
            log.info("Method name - " + method.getName());
            for (Object param : objects) {
                log.info("Parameter value - " + param);
            }
        };
    }
1
2
3
4
5
6
7
8
9
10
11
12

AsyncService类

    /**
     * 1.无参无返回值方法
     * 最简单的异步调用，返回值为void
     */
    @Async
    public void async() {
        log.info("无参无返回值方法，通过观察线程名称以便查看效果");
        int a = 1 / 0;
    }
1
2
3
4
5
6
7
8
9

AsyncDemo类

    @PostConstruct
    public void demo() {
        asyncA();
//        asyncB(1);
//        asyncC(11);
//        asyncD();
    }

    public void asyncA() {
        asyncService.async();
    }
1
2
3
4
5
6
7
8
9
10
11

有返回值的异步方法异常，需要手动try{}catch(){}处理

事务处理机制

在@Async标注的方法，同时也适用了@Transactional进行了标注；在其调用数据库操作之时，将无法产生事务管理的控制，原因就在于其是基于异步处理的操作。
那该如何给这些操作添加事务管理呢？可以将需要事务管理操作的方法放置到异步方法内部，在内部被调用的方法上添加@Transactional.
例如：
方法A，使用了@Async/@Transactional来标注，但是无法产生事务控制的目的。
方法B，使用了@Async来标注， B中调用了C，C使用@Transactional做了标注，则可实现事务控制的目的。

先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。深知大多数初中级java工程师，想要升技能，往往是需要自己摸索成长或是报班学习，但对于培训机构动则近万元的学费，着实压力不小。自己不成体系的自学效率很低又漫长，而且容易碰到天花板技术停止不前。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。添加下方名片，即可获取全套学习资料哦