Java 实现异步调用

被调用方法

package com.ruyi.async.controller;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

import java.util.Random;
import java.util.concurrent.Future;

@Component
public class AsyncBean {
    /**
     * 有返回值
     * @return Future<String>
     * @throws InterruptedException
     */
    @Async
    public Future<String> taskOneWithReturn() throws InterruptedException {
        System.out.println(">>> 开始执行异步任务..");
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Thread.sleep(new Random().nextInt(10000));
        stopWatch.stop();
        System.out.println("完成异步任务，耗时：" + stopWatch.getTotalTimeMillis() + "毫秒");
        return new AsyncResult<>(">>> 异步任务执行完成..");
    }

    /**
     * 无返回值
     * @throws InterruptedException
     */
    @Async
    public void taskTwoWithoutReturn() throws InterruptedException {
        System.out.println(">>> 开始执行异步任务..");
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        Thread.sleep(new Random().nextInt(10000));
        stopWatch.stop();
        System.out.println("完成异步任务，耗时：" + stopWatch.getTotalTimeMillis() + "毫秒");
    }
}

---

四种实现方式

package com.ruyi.async.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.concurrent.*;
import java.util.function.Supplier;

@RestController
public class TestController {

    @Resource
    private AsyncBean asyncBean;

    /**
     * 一、Thread
     */
    @RequestMapping(value = "byThread", method = RequestMethod.POST)
    public void byThread() {
        System.out.println(">>> main函数开始执行");

        Thread thread = new Thread(() -> {
            System.out.println("===task start===");
            try {
                asyncBean.taskOneWithReturn();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("===task finish===");
        });
        thread.start();

        System.out.println(">>> main函数执行结束");
    }


    /**
     * 二、Future
     * jdk8之前的实现方式，在JUC下增加了Future，从字面意思理解就是未来的意思。
     * 但使用起来却着实有点鸡肋，并不能实现真正意义上的异步，获取结果时需要阻塞线程，或者不断轮询。
     */
    @RequestMapping(value = "byFuture", method = RequestMethod.POST)
    public void byFuture() throws Exception {
        System.out.println("main函数开始执行");

        ExecutorService executor = Executors.newFixedThreadPool(1);
        Future<String> future = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                System.out.println("===task start===");
                Future<String> stringFuture = asyncBean.taskOneWithReturn();
                System.out.println("===task finish===");
                return stringFuture.toString();
            }
        });
        // 如果这里需要返回值，则会阻塞主线程。如果不需要返回值使用是OK的。倒也还能接受
        String result = future.get();
        System.out.println(result);
        System.out.println("main函数执行结束");

        // 不停轮询去获取异步的执行结果
        System.in.read();
    }

    /**
     * 三、CompletableFuture
     * 使用原生的CompletableFuture实现异步操作，加上对lambda的支持，可以说实现异步任务已经发挥到了极致。
     */
    @RequestMapping(value = "byCompletableFuture", method = RequestMethod.POST)
    public void byCompletableFuture() {
        System.out.println("main函数开始执行");

        ExecutorService executor = Executors.newFixedThreadPool(3);
        CompletableFuture<String> future = CompletableFuture.supplyAsync(new Supplier<String>() {
            @lombok.SneakyThrows
            @Override
            public String get() {
                System.out.println("===task start===");
                Future<String> stringFuture = null;
                try {
                    stringFuture = asyncBean.taskOneWithReturn();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("===task finish===");
                assert stringFuture != null;
                return stringFuture.get();
            }
        }, executor);
        // 如果获取返回值，则完美执行，但是一旦需要返回值，那么就跟普通的方法调用没啥区别了
//        String s = future.get();
        future.thenAccept(System.out::println);
        System.out.println("main函数执行结束");
    }

    /**
     * 四、Spring注解@Async 最优解
     *  需要在启动类添加注解@EnableAsync，开启异步调用
     *  关于这个返回值，如果不要返回值，那么一切顺利，一旦需要返回值，其实就跟普通调用差不多了
     */
    @RequestMapping(value = "byAsync", method = RequestMethod.POST)
    public void byAsync() throws Exception {
        System.out.println("main函数开始执行");
        asyncBean.taskTwoWithoutReturn();  // 无返回值
        Future<String> future = asyncBean.taskOneWithReturn();  // 有返回值，可以使用 future.get() 方法获取
        System.out.println("main函数执行结束");
//        System.out.println("异步执行结果：" + future.get());
    }


}