@Async注解详解+实例

时间：2024-10-22 08:13:56

一、@Async是什么？

异步调用@Async是Spring Boot里面的异步调用，异步调用相对的是同步调用。

同步：同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。

异步：异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。

例如：在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕； 如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。

二、同步调用

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

1、定义Task类，创建三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10秒内）

@Component
public class Task {

    public static Random random =new Random();

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

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

    public void doTaskThree() throws Exception {
        ("开始做任务三");
        long start = ();
        ((10000));
        long end = ();
        ("完成任务三，耗时：" + (end - start) + "毫秒");
    }

}

2、在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。 

@RunWith()
@SpringApplicationConfiguration(classes = )
public class ApplicationTests {

    @Autowired
    private Task task;

    @Test
    public void test() throws Exception {
        ();
        ();
        ();
    }

}

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

  • 开始做任务一
    完成任务一，耗时：4256毫秒

  • 开始做任务二
    完成任务二，耗时：4957毫秒

  • 开始做任务三
    完成任务三，耗时：7173毫秒

任务一、任务二、任务三顺序的执行完了，换言之doTaskOne、doTaskTwo、doTaskThree三个函数顺序的执行完成。

三、异步调用

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

在Spring Boot中，我们只需要通过使用@Async注解就能简单的将原来的同步函数变为异步函数，Task类改在为如下模式：

    public static Random random = new Random();

    @Async
    public Future<String> doTaskOne() throws Exception {
        ("开始做任务1");
        long start = ();
        ((10000));
        long end = ();
        ("完成任务1，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务1完成");
    }

    @Async
    public Future<String> doTaskTwo() throws Exception {
        ("开始做任务2");
        long start = ();
        ((10000));
        long end = ();
        ("完成任务2，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务2完成");
    }

    @Async
    public Future<String> doTaskThree() throws Exception {
        ("开始做任务3");
        long start = ();
        ((10000));
        long end = ();
        ("完成任务3，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务3完成");
    }

 

看看我们做了哪些改变：

  • 在测试用例一开始记录开始时间

  • 在调用三个异步函数的时候，返回Future类型的结果对象

  • 在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断。

跳出循环之后，根据结束时间 - 开始时间，计算出三个任务并发执行的总耗时。

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

开始做任务一
开始做任务二
开始做任务三
完成任务三，耗时：37毫秒
完成任务二，耗时：3661毫秒
完成任务一，耗时：7149毫秒
任务全部完成，总耗时：8025毫秒

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

相关文章