Java并发编程：从Thread到CompletableFuture

Java作为一门成熟的编程语言，在并发编程领域可谓是"老当益壮"。从最初的Thread到如今的CompletableFuture，Java的并发编程能力不断进化，让我们这些码农们欲罢不能。今天，就让我们一起来看看Java并发编程的演变史，看看它是如何从一个"单细胞生物"进化成"高等智慧生命"的。

远古时代：Thread类

在Java刚出生不久的年代，并发编程还是一个"原始人"的世界。那时候，我们只有Thread类这个"石器"可用。

public class PrimitiveTask extends Thread {
    @Override
    public void run() {
        System.out.println("我是一个原始人，我在用石器劳动");
    }
}

// 使用方式
new PrimitiveTask().start();

看起来很简单，对吧？但是，这种方式就像是用石器砍树，效率低下，而且容易"砍到自己的脚"。例如，你无法方便地获取线程的执行结果，也难以控制线程的生命周期。

青铜时代：Runnable接口

为了解决Thread类的一些限制，Java引入了Runnable接口。这就像是从石器进化到了青铜器，稍微先进了一点。

public class BronzeAgeTask implements Runnable {
    @Override
    public void run() {
        System.out.println("我是青铜时代的工人，使用青铜工具效率高多了");
    }
}

// 使用方式
new Thread(new BronzeAgeTask()).start();

Runnable接口让我们可以将任务的定义和执行分离，这是一个不小的进步。但是，我们仍然无法获取任务的执行结果，这就像是种了地却不知道能收获多少粮食，让人很是焦虑。

铁器时代：Callable和Future

终于，Java 5带来了Callable接口和Future接口，这就像是进入了铁器时代，生产力有了质的飞跃。

public class IronAgeTask implements Callable<String> {
    @Override
    public String call() throws Exception {
        return "我是铁器时代的工人，不仅效率高，还能告诉你我的劳动成果";
    }
}

// 使用方式
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new IronAgeTask());
try {
    String result = future.get();
    System.out.println(result);
} catch (Exception e) {
    e.printStackTrace();
} finally {
    executor.shutdown();
}

Callable允许我们定义有返回值的任务，而Future则让我们可以在未来某个时间点获取任务的执行结果。这就像是种地不仅知道收成如何，还可以预估产量，简直是农业生产的一次革命！

工业革命：ExecutorService

随着Java 5的到来，我们迎来了并发编程的"工业革命"——ExecutorService。它就像是一个现代化的工厂，可以高效地管理和调度线程。

ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
    final int taskId = i;
    executor.submit(() -> {
        System.out.println("工人" + taskId + "正在工厂流水线上工作");
    });
}
executor.shutdown();

ExecutorService让我们告别了手动创建和管理线程的繁琐，就像是从手工作坊进入了自动化工厂。但是，它仍然不够智能，无法很好地处理任务之间的依赖关系。

信息时代：CompletableFuture

终于，我们来到了Java 8，CompletableFuture的出现标志着Java并发编程进入了"信息时代"。它不仅能处理异步计算结果，还能将多个异步计算步骤组合起来，简直就是并发编程界的"人工智能"！

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    return "Hello";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
    return "World";
});

CompletableFuture<String> result = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);

result.thenAccept(System.out::println);

看看这个优雅的链式调用，是不是感觉整个人都变得智慧了？CompletableFuture允许我们以声明式的方式组合和处理异步操作，就像是给并发编程装上了"智能大脑"。

未来已来：虚拟线程（预览）

说到未来，不得不提Java 19引入的虚拟线程（目前还在预览阶段）。虚拟线程就像是给我们的程序插上了翅膀，让并发编程变得更加轻量和高效。

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}
// 10,000个任务，但只占用少量系统资源

虚拟线程的出现，让我们可以用同步的方式写异步代码，大大简化了并发编程的复杂度。这就像是从"平地起飞"变成了"垂直起降"，机动性大大提升！

总结

从Thread到CompletableFuture，再到虚拟线程，Java的并发编程能力经历了翻天覆地的变化。每一次进化都让我们的代码变得更加优雅、高效。但请记住，无论工具如何先进，核心始终是解决问题。过度使用并发可能会让你的程序变成一团浆糊，就像是给猪装上火箭发动机，除了制造混乱，什么也干不了。

所以，善用这些工具，但也要保持清醒。毕竟，我们的目标是写出优雅高效的代码，而不是炫技或者过度设计。在并发的世界里，保持简单可能是最大的智慧。

最后，让我们以一句话结束这篇文章：并发编程，道阻且长，行则将至，做则必成。加油，少年！

海码面试 小程序

包含最新面试经验分享，面试真题解析，全栈2000+题目库，前后端面试技术手册详解；无论您是校招还是社招面试还是想提升编程能力，都能从容面对~