[springboot]通过Async注解实现异步任务及回调

1. 环境准备

在 Spring Boot 入口类上配置 @EnableAsync 注解开启异步处理。
创建任务抽象类 AbstractTask，并实现三个任务方法 doTaskOne()，doTaskTwo()，doTaskThree()。

public abstract class AbstractTask {
    private static Random random = new Random();

    public void doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = currentTimeMillis();
        sleep(random.nextInt(10000));
        long end = currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
    }

    public void doTaskTwo() throws Exception {
        System.out.println("开始做任务二");
        long start = currentTimeMillis();
        sleep(random.nextInt(10000));
        long end = currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
    }

    public void doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = currentTimeMillis();
        sleep(random.nextInt(10000));
        long end = currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (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
 

2. 同步调用

下面通过一个简单示例来直观的理解什么是同步调用：

• 定义 Task 类，继承 AbstractTask，三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10 秒内）。

@Component
public class SyncTask extends AbstractTask {
}

  

 

  
1
  
2
  
3
 

• 在 单元测试 用例中，注入 SyncTask 对象，并在测试用例中执行 doTaskOne()，doTaskTwo()，doTaskThree() 三个方法。

@RunWith(SpringRunner.class)
@SpringBootTest
public class TaskTest {
    @Autowired
    private SyncTask task;

    @Test
    public void testSyncTasks() throws Exception {
        task.doTaskOne();
        task.doTaskTwo();
        task.doTaskThree();
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
 

• 执行单元测试，可以看到类似如下输出：

开始做任务一
完成任务一，耗时：6720毫秒
开始做任务二
完成任务二，耗时：6604毫秒
开始做任务三
完成任务三，耗时：9448毫秒

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

任务一、任务二、任务三顺序的执行完了，换言之 doTaskOne()，doTaskTwo()，doTaskThree() 三个方法按调用顺序的先后执行完成。

3. 异步调用

上述的 同步调用 虽然顺利的执行完了三个任务，但是可以看到 执行时间比较长，若这三个任务本身之间 不存在依赖关系，可以 并发执行 的话，同步调用在 执行效率 方面就比较差，可以考虑通过 异步调用 的方式来 并发执行。

• 在Application启动类上面加上@EnableAsync
• 创建 AsyncTask类，分别在方法上配置 @Async 注解，将原来的 同步方法 变为 异步方法。

@Component
public class AsyncTask extends AbstractTask {
    @Async
    public void doTaskOne() throws Exception {
        super.doTaskOne();
    }

    @Async
    public void doTaskTwo() throws Exception {
        super.doTaskTwo();
    }

    @Async
    public void doTaskThree() throws Exception {
        super.doTaskThree();
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
 

• 在 单元测试 用例中，注入 AsyncTask 对象，并在测试用例中执行 doTaskOne()，doTaskTwo()，doTaskThree() 三个方法。

@Autowired
private AsyncTask asyncTask;

@Test
public void testAsyncTasks() throws Exception {
    asyncTask.doTaskOne();
    asyncTask.doTaskTwo();
    asyncTask.doTaskThree();
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
 

• 执行单元测试，可以看到类似如下输出：

开始做任务三
开始做任务一
开始做任务二

  

 

  
1
  
2
  
3
 

如果反复执行单元测试，可能会遇到各种不同的结果，比如：

1. 没有任何任务相关的输出
2. 有部分任务相关的输出
3. 乱序的任务相关的输出

原因是目前 doTaskOne()，doTaskTwo()，doTaskThree() 这三个方法已经 异步并发执行 了。主程序在 异步调用 之后，主程序并不会理会这三个函数是否执行完成了，由于没有其他需要执行的内容，所以程序就 自动结束 了，导致了任务 不完整 或是 没有输出 相关内容的情况。

注意：@Async所修饰的函数不要定义为static类型，这样异步调用不会生效。

4. 异步回调

为了让 doTaskOne()，doTaskTwo()，doTaskThree() 能正常结束，假设我们需要统计一下三个任务 并发执行 共耗时多少，这就需要等到上述三个函数都完成动用之后记录时间，并计算结果。

那么我们如何判断上述三个 异步调用 是否已经执行完成呢？我们需要使用 Future<T> 来返回 异步调用 的 结果。

• 创建 AsyncCallBackTask 类，声明 doTaskOneCallback()，doTaskTwoCallback()，doTaskThreeCallback() 三个方法，对原有的三个方法进行包装。

@Component
public class AsyncCallBackTask extends AbstractTask {
    @Async
    public Future<String> doTaskOneCallback() throws Exception {
        super.doTaskOne();
        return new AsyncResult<>("任务一完成");
    }

    @Async
    public Future<String> doTaskTwoCallback() throws Exception {
        super.doTaskTwo();
        return new AsyncResult<>("任务二完成");
    }

    @Async
    public Future<String> doTaskThreeCallback() throws Exception {
        super.doTaskThree();
        return new AsyncResult<>("任务三完成");
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
 

• 在 单元测试 用例中，注入 AsyncCallBackTask 对象，并在测试用例中执行 doTaskOneCallback()，doTaskTwoCallback()，doTaskThreeCallback() 三个方法。循环调用 Future 的 isDone() 方法等待三个 并发任务 执行完成，记录最终执行时间。

@Autowired
private AsyncCallBackTask asyncCallBackTask;

@Test
public void testAsyncCallbackTask() throws Exception {
    long start = currentTimeMillis();
    Future<String> task1 = asyncCallBackTask.doTaskOneCallback();
    Future<String> task2 = asyncCallBackTask.doTaskTwoCallback();
    Future<String> task3 = asyncCallBackTask.doTaskThreeCallback();

    // 三个任务都调用完成，退出循环等待
    while (!task1.isDone() || !task2.isDone() || !task3.isDone()) {
        sleep(1000);
    }

    long end = currentTimeMillis();
    System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
 

看看都做了哪些改变：

• 在测试用例一开始记录开始时间；
• 在调用三个异步函数的时候，返回Future类型的结果对象；
• 在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。
• 跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。

执行一下上述的单元测试，可以看到如下结果：

开始做任务三
开始做任务一
开始做任务二
完成任务二，耗时：2572毫秒
完成任务一，耗时：7333毫秒
完成任务三，耗时：7647毫秒
任务全部完成，总耗时：8013毫秒

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

可以看到，通过 异步调用，让任务一、任务二、任务三 并发执行，有效的 减少 了程序的 运行总时间。

文章来源: zimug.blog.csdn.net，作者：字母哥哥，版权归原作者所有，如需转载，请联系作者。

原文链接：zimug.blog.csdn.net/article/details/122893230