7 种异步编程实现方式！性能炸裂！！拿捏了

谁借莪１个温暖的怀抱￠ 2023-09-23 14:34 77阅读 0赞

最近有很多小伙伴给我留言，能不能总结下异步编程，今天就和大家简单聊聊这个话题。

早期的系统是同步的，容易理解，我们来看个例子

**同步编程**

![729ee210af276cd4e5358d85e6335a86.jpeg][]

当用户创建一笔电商交易订单时，要经历的业务逻辑流程还是很长的，每一步都要耗费一定的时间，那么整体的 RT 就会比较长。

**异步编程**

于是，聪明的人们开始思考能不能将一些非核心业务从主流程中剥离出来，于是有了异步编程雏形。

异步编程是让程序并发运行的一种手段。它允许多个事件同时发生，当程序调用需要长时间运行的方法时，它不会阻塞当前的执行流程，程序可以继续运行。

![993be604de9c5dfac0d40f5f64eab158.jpeg][]

核心思路：采用多线程优化性能，将串行操作变成并行操作。异步模式设计的程序可以显著减少线程等待，从而在高吞吐量场景中，极大提升系统的整体性能，显著降低时延。

接下来，我们来讲下异步有哪些编程实现方式。

## 一、Thread ##

直接继承 `Thread类` 是创建异步线程最简单的方式。

首先，创建 `Thread` 子类，普通类或匿名内部类方式；然后创建子类实例；最后通过 `start()`方法启动线程。

public class AsyncThread extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程名称:" + this.getName() + ", 执行线程名称:" + Thread.currentThread().getName() + "-hello");
        }
    }
    public static void main(String[] args) {
    
        // 模拟业务流程
        // .......
        // 创建异步线程
        AsyncThread asyncThread = new AsyncThread();
        // 启动异步线程
        asyncThread.start();
    }

当然如果每次都创建一个 `Thread` 线程，频繁的创建、销毁，浪费系统资源。我们可以采用线程池

@Bean(name = "executorService")
    public ExecutorService downloadExecutorService() {
        return new ThreadPoolExecutor(20, 40, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2000),
                new ThreadFactoryBuilder().setNameFormat("defaultExecutorService-%d").build(),
                (r, executor) -> log.error("defaultExecutor pool is full! "));
    }

将业务逻辑封装到 `Runnable` 或 `Callable` 中，交由 `线程池` 来执行

![c1a85fb6f9228efe620d62adf9dd7395.jpeg][]

## 二、Future ##

上述方式虽然达到了多线程并行处理，但有些业务不仅仅要执行过程，还要获取执行结果。

Java 从 1.5 版本开始，提供了 `Callable` 和 `Future`，可以在任务执行完毕之后得到任务执行结果。

当然也提供了其他功能，如：取消任务、查询任务是否完成等

`Future` 类位于 `java.util.concurrent` 包下，接口定义：

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
 *  `isCancelled()`：表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true
 *  `isDone()`：表示任务是否已经完成，如果完成，返回 true
 *  `get()`：获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回
 *  `get(long timeout, TimeUnit unit)`：用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回 null

**代码示例：**

public class CallableAndFuture {
    
        public static ExecutorService executorService = new ThreadPoolExecutor(4, 40,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1024), new ThreadFactoryBuilder()
                .setNameFormat("demo-pool-%d").build(), new ThreadPoolExecutor.AbortPolicy());
    
    
        static class MyCallable implements Callable<String> {
            @Override
            public String call() throws Exception {
                return "异步处理，Callable 返回结果";
            }
        }
    
        public static void main(String[] args) {
            Future<String> future = executorService.submit(new MyCallable());
            try {
                System.out.println(future.get());
            } catch (Exception e) {
                // nodo
            } finally {
                executorService.shutdown();
            }
        }
    }

`Future` 表示一个可能还没有完成的异步任务的结果，通过 `get` 方法获取执行结果，该方法会阻塞直到任务返回结果。

## 三、FutureTask ##

`FutureTask` 实现了 `RunnableFuture` 接口，则 `RunnableFuture` 接口继承了`Runnable` 接口和 `Future` 接口，所以可以将 `FutureTask` 对象作为任务提交给 `ThreadPoolExecutor` 去执行，也可以直接被 `Thread` 执行；又因为实现了`Future` 接口，所以也能用来获得任务的执行结果。

**FutureTask 构造函数：**

public FutureTask(Callable<V> callable)
    public FutureTask(Runnable runnable, V result)

`FutureTask` 常用来封装 `Callable` 和 `Runnable`，可以作为一个任务提交到线程池中执行。除了作为一个独立的类之外，也提供了一些功能性函数供我们创建自定义 task 类使用。

`FutureTask` 线程安全由 CAS 来保证。

ExecutorService executor = Executors.newCachedThreadPool();
    // FutureTask包装callbale任务，再交给线程池执行
    FutureTask<Integer> futureTask = new FutureTask<>(() -> {
        System.out.println("子线程开始计算：");
        Integer sum = 0;
        for (int i = 1; i <= 100; i++)
            sum += i;
        return sum;
    });
    
    // 线程池执行任务， 运行结果在 futureTask 对象里面
    executor.submit(futureTask);
    
    try {
        System.out.println("task运行结果计算的总和为：" + futureTask.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
    executor.shutdown();

> `Callable` 和 `Future` 的区别：`Callable` 用于产生结果，`Future` 用于获取结果

![0bc71461af9bf714c027761bbeb59252.jpeg][]

如果是对多个任务多次自由串行、或并行组合，涉及多个线程之间同步阻塞获取结果，`Future` 代码实现会比较繁琐，需要我们手动处理各个交叉点，很容易出错。

## 四、异步框架 CompletableFuture ##

`Future` 类通过 `get()` 方法阻塞等待获取异步执行的运行结果，性能比较差。

JDK1.8 中，Java 提供了 `CompletableFuture` 类，它是基于异步函数式编程。相对阻塞式等待返回结果，`CompletableFuture` 可以通过回调的方式来处理计算结果，实现了异步非阻塞，性能更优。

**优点**：

*  异步任务结束时，会自动回调某个对象的方法
 *  异步任务出错时，会自动回调某个对象的方法
 *  主线程设置好回调后，不再关心异步任务的执行

**泡茶示例：**

![e81d198a016fad247c7d2f14b13cc32d.jpeg][]

//任务1：洗水壶->烧开水
    CompletableFuture<Void> f1 =
            CompletableFuture.runAsync(() -> {
                System.out.println("T1:洗水壶...");
                sleep(1, TimeUnit.SECONDS);
    
                System.out.println("T1:烧开水...");
                sleep(15, TimeUnit.SECONDS);
            });
    
    //任务2：洗茶壶->洗茶杯->拿茶叶
    CompletableFuture<String> f2 =
            CompletableFuture.supplyAsync(() -> {
                System.out.println("T2:洗茶壶...");
                sleep(1, TimeUnit.SECONDS);
    
                System.out.println("T2:洗茶杯...");
                sleep(2, TimeUnit.SECONDS);
    
                System.out.println("T2:拿茶叶...");
                sleep(1, TimeUnit.SECONDS);
                return "龙井";
            });
    
    //任务3：任务1和任务2完成后执行：泡茶
    CompletableFuture<String> f3 =
            f1.thenCombine(f2, (__, tf) -> {
                System.out.println("T1:拿到茶叶:" + tf);
                System.out.println("T1:泡茶...");
                return "上茶:" + tf;
            });
    
    //等待任务3执行结果
    System.out.println(f3.join());
    
    }

`CompletableFuture` 提供了非常丰富的 API，大约有 50 种处理串行，并行，组合以及处理错误的方法。

[729ee210af276cd4e5358d85e6335a86.jpeg]: https://img-blog.csdnimg.cn/img_convert/729ee210af276cd4e5358d85e6335a86.jpeg
[993be604de9c5dfac0d40f5f64eab158.jpeg]: https://img-blog.csdnimg.cn/img_convert/993be604de9c5dfac0d40f5f64eab158.jpeg
[c1a85fb6f9228efe620d62adf9dd7395.jpeg]: https://img-blog.csdnimg.cn/img_convert/c1a85fb6f9228efe620d62adf9dd7395.jpeg
[0bc71461af9bf714c027761bbeb59252.jpeg]: https://img-blog.csdnimg.cn/img_convert/0bc71461af9bf714c027761bbeb59252.jpeg
[e81d198a016fad247c7d2f14b13cc32d.jpeg]: https://img-blog.csdnimg.cn/img_convert/e81d198a016fad247c7d2f14b13cc32d.jpeg