spring方法异步调用async,spring异步注解

　　00-1010前言什么是异步调用？1.环境准备2。同步呼叫3。异步调用4。异步回调。

目录

　　00-1010异步调用是相对于同步调用的。同步调用是指程序按照预定的顺序一步一步执行，每一步都要等到前一步完成。异步调用可以在不等待上一步的情况下执行。异步调用可以减少程序执行时间。

前言

　　在Spring Boot入口类上配置@EnableAsync批注以打开异步处理。创建AbstractTask类AbstractTask，实现三个任务方法doTaskOne()、doTaskTwo()、doTaskThree()。

　　公共抽象类AbstractTask {私有静态随机Random=new Random()；void dotaskone()throws exception { system . out . println(开始任务一)；long start=current time millis()；sleep(random . nextint(10000))；long end=current time millis()；System.out.println(任务一完成，需要时间：(end-start)毫秒)；} public void dotask two()throws exception { system . out . println(开始任务二)；long start=current time millis()；sleep(random . nextint(10000))；long end=current time millis()；System.out.println(任务2完成，耗时：(end-start)毫秒)；} public void dotaskstrie()throws exception { system . out . println(开始做任务三)；long start=current time millis()；sleep(random . nextint(10000))；long end=current time millis()；System.out.println(任务三完成，耗时：(end-start)毫秒)；}}

　　00-1010这里有一个简单的例子可以直观地理解什么是同步调用：

　　定义任务类，继承AbstractTask，三个处理函数分别模拟三个任务的操作，操作消耗时间随机取(10秒以内)。

　　@ component公共类SyncTask在单元测试用例中扩展抽象task {}，注入synctask对象，在测试用例中执行doTaskOne()、doTaskTwo()和doTaskThree()。

　　@ run with(spring runner . class)@ spring boot test public class task test { @ auto wired private sync task task；@Test public void testSyncTasks()抛出异常{ task . dotaskone()；task . dotaskwone()；task . dotaskstrie()；}}执行单元测试，可以看到类似如下的输出：

　　开始任务1，完成任务1，耗时：6720ms，开始任务2，完成任务2，耗时：6604ms，开始任务3，完成任务3，

　　耗时：9448毫秒

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

3. 异步调用

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

@Componentpublic 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(); }}

@Autowiredprivate AsyncTask asyncTask;@Testpublic void testAsyncTasks() throws Exception { asyncTask.doTaskOne(); asyncTask.doTaskTwo(); asyncTask.doTaskThree();}

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

　　

　　没有任何任务相关的输出有部分任务相关的输出乱序的任务相关的输出

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

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

　　

4. 异步回调

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

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

@Componentpublic 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<>("任务三完成"); }}

@Autowiredprivate AsyncCallBackTask asyncCallBackTask;@Testpublic 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) + "毫秒");}

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

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

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

　　

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。