Java多线程神器——ThreadForge ，让多线程从此简单

在 Java 开发的世界里，多线程一直是一把双刃剑。它既是提升性能的利器，也是引发各种诡异 Bug 的温床。

你是否经历过这样的场景：为了优化一个慢接口，你决定将几个串行的 RPC 调用改为并发执行。于是，你熟练地创建了线程池，提交了任务，拿到了 Future 对象。但紧接着，问题接踵而至：

超时处理 ：每个 future.get() 都要手写超时时间，繁琐且易错。
资源泄漏 ：稍不注意就忘了 executor.shutdown()，导致线程池泄漏。
异常处理 ：一个任务失败了，其他任务怎么办？是继续等待还是全部取消？Future 本身并不提供这些策略。
代码臃肿 ：一个简单的并发需求，最终却写出了五六十行充斥着 try-catch-finally 的"样板代码"。

传统的 ExecutorService、Future 乃至 CompletableFuture 虽然功能强大，但也足够"啰嗦"。它们把太多的复杂性暴露给了开发者，让你不得不去关注线程的生命周期、异常的传播、资源的清理等边界情况，而不是专注于业务逻辑本身。

今天，我们来认识一个旨在解决这些痛点的 Java 并发新框架------ThreadForge 。它的目标非常明确：让 Java 并发编程变得简单、清晰、可推理。

🤔 ThreadForge 是什么？

你可以把 ThreadForge 理解为一个结构化并发（Structured Concurrency）框架 。它的核心思想是：用写同步代码的思维来写并发代码。

它通过将一组相关的并发任务约束在一个明确的生命周期作用域（ThreadScope）内，自动处理任务的创建、执行、超时、失败传播和资源清理。这让并发代码的结构变得清晰，逻辑关系一目了然，同时避免了资源泄漏和"孤儿线程"等常见问题。

🚀 核心概念：ThreadScope

ThreadScope 是 ThreadForge 的心脏。它就像一个容器，所有相关的并发任务都必须在这个容器内提交和执行。当这个容器关闭时（例如，通过 try-with-resources 语句），它会自动确保所有任务都得到妥善处理------无论是成功完成、失败还是被取消。

让我们通过一个经典的"用户详情页"优化案例，来看看 ThreadForge 如何让代码变得简洁。

传统写法 vs. ThreadForge 写法

场景：一个用户详情页需要同时获取用户信息、订单列表和积分余额，三个接口串行调用耗时 600ms，现在要改为并发调用。

使用 ThreadForge，代码可以精简到十几行：

scss 复制代码

public UserDetailVO getUserDetail(Long userId) {
    // try-with-resources 确保作用域关闭时，所有资源被自动清理
    try (ThreadScope scope = ThreadScope.open()) {
        // 提交三个并发任务，并给它们起个名字，方便日志排查
        Task<User> userTask = scope.submit("查询用户信息", () -> userService.getById(userId));
        Task<List<Order>> orderTask = scope.submit("查询用户订单", () -> orderService.listByUserId(userId));
        Task<Integer> pointTask = scope.submit("查询用户积分", () -> pointService.getByUserId(userId));

        // 等待所有任务完成
        scope.await(userTask, orderTask, pointTask);

        // 获取结果并组装返回
        User user = userTask.await();
        List<Order> orders = orderTask.await();
        Integer point = pointTask.await();

        return UserDetailVO.builder()
                .id(user.getId())
                .username(user.getUsername())
                .orders(orders)
                .point(point)
                .build();
    } catch (Exception e) {
        log.error("获取用户详情失败，userId:{}", userId, e);
        throw new BusinessException("获取用户详情失败");
    }
}

这段代码的优势非常明显：

生命周期清晰 ：所有任务都绑定在 scope 内，作用域结束，任务生命周期也随之结束，杜绝了线程泄漏。
默认即安全：无需手动配置，框架默认提供了 30 秒超时、失败后自动取消其他任务等安全策略。
结构即逻辑：代码结构清晰地表达了"这三个任务是并发的，且都必须成功才能继续"的业务逻辑。

✨ 五大核心特性

ThreadForge 的设计哲学是"先降低认知成本，再追求性能"。它通过以下几个特性，将并发编程的复杂性封装起来。

1. 默认行为就是正确的

你不需要成为并发专家也能写出健壮的代码。ThreadScope.open() 创建的默认作用域就具备了：

快速失败 (FAIL_FAST) ：任何一个任务失败，都会立即取消其他所有任务。
全局超时：默认 30 秒超时，防止任务无限期挂起。
异常传播：任务中的异常会被清晰地包装和抛出，方便统一处理。

2. 明确的失败策略

不同的业务场景对失败的容忍度不同。ThreadForge 提供了 5 种清晰的失败策略，让你可以根据需要灵活选择：

FAIL_FAST (默认) ：快速失败。一个任务出错，立即取消其他任务。适用于所有任务都成功才算成功的场景。
COLLECT_ALL：收集所有结果。等待所有任务执行完毕，无论成功或失败。适用于批量处理，需要知道哪些成功、哪些失败的场景。
SUPERVISOR ：监督者模式。不自动取消任务，而是将所有任务的执行结果（成功/失败）汇总到一个 Outcome 对象中，由你自行处理。
CANCEL_OTHERS：取消其余。一个任务失败后取消其他任务，但自身不抛出异常。
IGNORE_ALL：忽略所有失败。只关心成功的结果。

例如，在批量导入数据时，即使部分失败也要继续，并统计最终结果：

scss 复制代码

try (ThreadScope scope = ThreadScope.open()
        .withFailurePolicy(FailurePolicy.COLLECT_ALL)) {
    List<Task<Void>> tasks = importList.stream()
            .map(dto -> scope.submit("导入用户-" + dto.getUsername(), () -> importUser(dto)))
            .collect(Collectors.toList());

    // 等待所有任务完成，并获取汇总结果
    Outcome outcome = scope.await(tasks);

    log.info("导入完成。成功: {}, 失败: {}", outcome.successCount(), outcome.failureCount());
}

3. 简洁的并发度控制

当需要调用外部 API 时，为了避免瞬间流量过大打垮对方服务，我们需要限制并发请求的数量。ThreadForge 让你无需手动管理信号量或线程池队列。

ini 复制代码

// 限制最多同时执行 50 个任务
try (ThreadScope scope = ThreadScope.open().withConcurrencyLimit(50)) {
    List<Task<Result>> tasks = hugeIdList.stream()
            .map(id -> scope.submit(() -> externalApi.call(id)))
            .collect(Collectors.toList());
    List<Result> results = scope.awaitAll(tasks);
}

4. 强大的任务编排 (v1.2.0+)

在 1.2.0 版本中，ThreadForge 引入了更高级的编排 API，可以轻松应对复杂的并发模式。

firstSuccess：竞速模式。发起多个请求，只要有一个成功就立即返回结果，并取消其余请求。非常适合多机房兜底或多供应商 fallback 的场景。
scss 复制代码
```
String result = scope.joiner().firstSuccess(() -> providerA.call(), () -> providerB.call());
```
quorum(n) ：法定人数模式。等待至少 n 个任务成功就返回。适用于需要多数派确认的容错查询。
scss 复制代码
```
List<String> results = scope.joiner().quorum(2, () -> replicaA.call(), () -> replicaB.call(), () -> replicaC.call());
```
hedged(delay) ：对冲请求模式。先发起一个主请求，如果超过指定时间未完成，则再发起一个备用请求。这是消除长尾延迟（Tail Latency）的利器。
scss 复制代码
```
String result = scope.joiner().hedged(Duration.ofMillis(50), () -> primaryCall(), () -> backupCall());
```

5. 统一的生命周期观测

ThreadForge 将任务的执行状态、耗时、异常等信息统一收口，并原生支持 OpenTelemetry，让并发任务的可观测性变得非常简单。你可以轻松地为任务添加追踪（Tracing）、指标（Metrics）和日志，快速定位性能瓶颈和故障点。

📦 快速开始

ThreadForge 的使用非常便捷，无论是 Spring Boot 项目还是普通 Java 应用都能轻松集成。

Maven 依赖

xml 复制代码

<dependency>
    <groupId>pub.lighting</groupId>
    <artifactId>threadforge-core</artifactId>
    <version>1.2.0</version>
</dependency>

Spring Boot 配置 (可选)

如果你使用 Spring Boot，可以通过 application.yml 进行简单配置，无需编写任何 Java Config。

yaml 复制代码

threadforge:
  default-timeout: 30s # 全局默认超时
  core-pool-size: 8    # 核心线程数
  max-pool-size: 16    # 最大线程数

📌 总结

ThreadForge 的出现，标志着 Java 并发编程正在进入一个更高级、更抽象的新时代。它并非要取代 ExecutorService 或 CompletableFuture，而是对它们进行了一次优雅的封装，将开发者从繁琐、易错的底层细节中解放出来。

它让你能够：

专注于业务：不再被线程管理、超时、取消等"脏活累活"分散精力。
写出更清晰的代码：代码结构直接反映了任务的并发关系和依赖关系。
构建更健壮的系统：通过默认的安全策略和自动化的资源管理，有效避免了常见的并发陷阱。

如果你正在为项目中日益复杂的并发代码而感到头疼，那么 ThreadForge 绝对值得你一试。它或许就是那个能让你的多线程编程从此变得简单的"神器"。