谈谈@Async注解以及Future类型

这是我参与更文挑战的第1天，活动详情查看： 更文挑战

@Async 实现异步调用

“异步调用”对应的是“同步调用”，同步调用指程序按照定义顺序依次执行，每一行程序都必须等待上一行程序执行完成之后才能执行；异步调用指程序在顺序执行时，不等待异步调用的语句返回结果就执行后面的程序。

顾名思义，@Async是用来实现异步的。基于@Async的方法，称之为异步方法。这些方法将在执行的时候，将会在独立的线程中被执行，调用者无需等待它的完成，即可继续其他的操作。

那么在Spring中如何使用@Async实现异步调用呢？

假如我们有一个Task类，其中有三个任务需要异步执行，那么我们就可以将这些任务方法标上@Async注解，使其成为异步方法。代码如下：

@Component
public class AsyncTask {
    private static Random random = new Random();

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

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

    @Async
    public void doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
    }
}
复制代码

为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置@EnableAsync，如下所示：

@SpringBootApplication
@EnableAsync
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}
复制代码

然后我们可以写一个单元测试进行测试一下：

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
public class ApplicationTests {
    @Autowired
    private Task task;
	
    @Test
    public void test() throws Exception {
	task.doTaskOne();
	task.doTaskTwo();
	task.doTaskThree();
    }
}
复制代码

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

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

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

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

Funture 类型

那么问题来了，什么是Future类型呢？

Future是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果的接口。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

它的接口定义如下：

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
复制代码

它声明这样的五个方法：

• cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
• isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
• isDone方法表示任务是否已经完成，若任务完成，则返回true；
• get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
• get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

也就是说Future提供了三种功能：

• 判断任务是否完成；
• 能够中断任务；
• 能够获取任务执行结果。

对于上面的Task类，我们也可以简单修改一下，判断上述三个异步调用是否已经执行完成。类似于如下doTaskOne()代码进行修改：

    @Async
    public Future<String> doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务一完成");
    }
复制代码

然后我们再修改一下单元测试方法：

    @Test
    public void asyncTaskTest() throws Exception {
        long start = System.currentTimeMillis();

        Future<String> task1 = asyncTask.doTaskOne();
        Future<String> task2 = asyncTask.doTaskTwo();
        Future<String> task3 = asyncTask.doTaskThree();

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

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

输出结果如下：

开始做任务一
开始做任务二
开始做任务三
完成任务二，耗时：5352毫秒
完成任务一，耗时：7190毫秒
完成任务三，耗时：7525毫秒
任务全部完成，总耗时：8004毫秒
复制代码

总结

如果在业务场景中我们有异步以及需要知道异步方法执行结果的需求，那么@Async以及Future的组合会是个不错的选择。另外 Java 8 中添加了新类 CompletableFuture 感兴趣的同学也可以自行进行更多的尝试。

链接：

• 程序猿DD的Spring Boot教程-Spring Boot中使用@Async实现异步调用
• 程序猿DD的Spring Boot教程-Spring Boot使用@Async实现异步调用：自定义线程池
• 程序猿DD的Spring Boot教程-Spring Boot使用@Async实现异步调用：ThreadPoolTaskScheduler线程池的优雅关闭
• 程序猿DD的Spring Boot教程-Spring Boot使用@Async实现异步调用：使用Future以及定义超时
• Completablefuture的一些列子