拿下美团实习~

最近正是找实习的大好时机，互联网各家也分别官宣了他们的招聘计划。

京 * 宣布要招聘 10000 人，腾 * 宣布要招聘 7000 人，字 * 宣布要招 4000 人，美 * 宣布了他们要招聘 5000 人，并且公布了 70% 的高转正率：

alt

（图片来自：美团公众号，侵权联系可删）

这不，这两天有同学面试美团，被拷打了 1 个多小时，其中有一道问题印象深刻：如何实现多线程任务编排？

接下来咱们就具体聊聊这个问题。

定义

线程编排定义：多线程任务编排指的是对多个线程任务按照一定的逻辑顺序或条件进行组织和安排，以实现协同工作、顺序执行或并行执行的一种机制。

如下图所示，其中任务二需要等任务一执行完成之后再执行，而任务四要等任务二和任务三执行完成之后再执行，这个时候就需要任务编排机制来保证任务的执行顺序：

alt

实现方式

线程的任务编排的实现方式主要有以下两种：

FutureTask：诞生于 JDK 1.5，它实现了 Future 接口和 Runnable 接口，设计初衷是为了支持可取消的异步计算。它既可以承载 Runnable 任务（通过包装成 RunnableAdapter），也可以承载 Callable 任务，从而能够返回计算结果，使用它可以实现简单的异步任务执行和结果的等待。
CompletableFuture：诞生于 JDK 8，它不仅实现了 Future 接口，还实现了 CompletionStage 接口。CompletionStage 是对 Future 的扩展，提供了丰富的链式异步编程模型，支持函数式编程风格，可以更加灵活地处理异步操作的组合和依赖回调等。

FutureTask 使用案例

FutureTask 使用示例如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FutureTaskDemo {
    public static void main(String[] args) {
        // 创建一个Callable任务
        Callable<Integer> task = () -> {
            Thread.sleep(2000); // 模拟任务耗时操作
            return 10; // 返回任务结果
        };

        // 创建FutureTask，并将Callable任务包装起来
        FutureTask<Integer> futureTask = new FutureTask<>(task);

        // 创建线程池
        ExecutorService executor = Executors.newCachedThreadPool();

        // 提交FutureTask给线程池执行
        executor.submit(futureTask);

        try {
            // 获取任务结果，get()方法会阻塞直到任务完成并返回结果
            int result = futureTask.get();
            System.out.println("任务结果：" + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，通过创建一个 Callable 任务来模拟耗时操作，并使用 FutureTask 包装该任务。然后将 FutureTask 提交给线程池执行，最后通过 get() 方法获取任务的执行结果，之后才会执行后续流程。我们可以通过 get() 方法阻塞等待程序执行结果，从而完成线程任务的简单编排。

CompletableFuture 使用案例

从上面 FutureTask 实现代码可以看出，它不但写法麻烦，而且需要使用 get() 方法阻塞等待线程的执行结果，对于异步任务的执行来说，不够灵活且效率也会受影响，然而 CompletableFutrue 的出现，则弥补了 FutureTask 的这些缺陷。

CompletableFutrue 提供的方法有很多，但最常用和最实用的核心方法只有以下几个：

alt

例如，我们现在实现一个这样的场景：

alt

任务描述：任务一执行完之后执行任务二，任务三和任务一和任务二一起执行，所有任务都有返回值，等任务二和任务三执行完成之后，再执行任务四，它的实现代码如下：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {

    public static void main(String[] args) {
        // 任务一：返回 "Task 1 result"
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 1 result";
        });
        // 任务二：依赖任务一，返回 "Task 2 result" + 任务一的结果
        CompletableFuture<String> task2 = task1.handle((result1, throwable) -> {
            try {
                // 模拟耗时操作
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 2 result " + result1;
        });
        // 任务三：和任务一、任务二并行执行，返回 "Task 3 result"
        CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(800); // 任务三可能比任务二先完成
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException(e);
            }
            return "Task 3 result";
        });
        // 任务四：依赖任务二和任务三，等待它们都完成后执行，返回 "Task 4 result" + 任务二和任务三的结果
        CompletableFuture<String> task4 = CompletableFuture.allOf(task2, task3).handle((res, throwable) -> {
            try {
                // 这里不需要显式等待，因为 allOf 已经保证了它们完成
                return "Task 4 result with " + task2.get() + " and " + task3.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        });
        // 获取任务四的结果并打印
        String finalResult = task4.join();
        System.out.println(finalResult);
    }
}