Java并发之流水线模式以及CompletableFuture实战

zhangzeyuaaa

已于 2025-05-09 11:53:04 修改

阅读量715

点赞数 20

CC 4.0 BY-SA版权

分类专栏： Java并发文章标签： java 开发语言

于 2025-05-09 11:45:57 首次发布

本文链接：https://blog.youkuaiyun.com/zhangzeyuaaa/article/details/147817459

Java并发专栏收录该内容

43 篇文章

订阅专栏

Java并发之流水线模式

1. 流水线模式概述

在Java并发编程中，流水线（Pipeline）模式是一种将任务拆分为多个阶段依次处理的并发模型。这种模式通过将任务分解为多个独立的步骤，并为每个步骤分配独立的线程池，从而实现任务的并行化处理。流水线模式的核心思想是将复杂的任务分解为多个简单的阶段，每个阶段专注于完成特定的功能，并通过线程池实现并发执行。

流水线模式的优势在于：

避免共享状态：每个阶段之间无需共享状态，降低了并发冲突的可能性。
提高硬件利用率：通过合理设计线程池规模，可以充分利用CPU和IO资源。
任务解耦：每个阶段独立运行，便于扩展和维护。

然而，这种模式也存在一些挑战：

回调地狱：嵌套的异步调用可能导致代码可读性下降。
线程池管理复杂：需要合理配置线程池大小和生命周期管理。
任务顺序依赖：流水线中的任务必须按顺序执行，可能导致性能瓶颈。

2. 代码示例分析

以下是一个典型的流水线模式实现示例：

import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class PipLineTest {
    public static void main(String[] args) {
        // 创建线程池
        ExecutorService readPool = Executors.newFixedThreadPool(2);
        ExecutorService processPool = Executors.newFixedThreadPool(20);
        ExecutorService writePool = Executors.newFixedThreadPool(3);

        // 提交1000个任务
        for (int i = 0; i < 1000; i++) {
            readPool.submit(() -> {
                String uuid = UUID.randomUUID().toString();
                processPool.submit(() -> {
                    String upperUuid = uuid.toUpperCase();
                    try {
                        Thread.sleep(10); // 模拟处理耗时
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    writePool.submit(() -> {
                        System.out.println(upperUuid);
                    });
                });
            });
        }

        // 关闭线程池
        shutdownAndAwaitTermination(readPool, "readPool");
        shutdownAndAwaitTermination(processPool, "processPool");
        shutdownAndAwaitTermination(writePool, "writePool");
    }

    // 线程池关闭方法
    private static void shutdownAndAwaitTermination(ExecutorService pool, String poolName) {
        pool.shutdown();
        try {
            if (!pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) {
                pool.shutdownNow();
            }
        } catch (InterruptedException e) {
            pool.shutdownNow();
        }
        System.out.println(poolName + " has shutdown !!");
    }
}

2.1 代码结构解析

线程池划分：
- readPool：负责生成UUID（读取阶段）。
- processPool：负责将UUID转换为大写（处理阶段）。
- writePool：负责输出结果到控制台（写入阶段）。
任务流程：
- 每个任务从readPool开始，生成一个UUID。
- 通过processPool对UUID进行处理（转换为大写）。
- 最终由writePool完成输出操作。
线程池关闭：
- 使用shutdown()和awaitTermination()确保线程池优雅关闭。
- 通过shutdownNow()处理异常情况。

3. 流水线模式的优缺点

3.1 优点

避免共享状态：
- 每个阶段的数据传递是单向的，无需共享状态，降低了并发冲突的风险。
- 例如，在代码示例中，readPool生成的UUID直接传递给processPool，无需考虑线程安全问题。
提高硬件利用率：
- 通过合理配置线程池规模，可以充分利用CPU和IO资源。
- 例如，readPool仅需2个线程，而processPool需要20个线程，因为处理阶段可能涉及更复杂的计算。
任务解耦：
- 每个阶段独立运行，便于扩展和维护。
- 例如，可以单独优化processPool的性能，而不影响其他阶段。
支持异步处理：
- 通过线程池实现任务的异步执行，提高整体吞吐量。

3.2 缺点

回调地狱：
- 嵌套的submit()调用可能导致代码可读性下降。
- 例如，代码示例中readPool.submit()内部嵌套了processPool.submit()和writePool.submit()。
线程池管理复杂：
- 需要合理配置线程池大小和生命周期管理。
- 例如，processPool的线程数设置为20，需要根据实际负载调整。
任务顺序依赖：
- 流水线中的任务必须按顺序执行，可能导致性能瓶颈。
- 例如，readPool和processPool之间的任务必须严格按顺序传递。
异常处理复杂：
- 异常传播需要额外处理，否则可能导致任务失败。
- 例如，代码示例中未处理processPool或writePool中的异常。

4. 优化建议

4.1 使用`CompletableFuture`简化流水线

CompletableFuture是Java 8引入的异步编程工具，可以简化流水线的实现。以下是优化后的代码示例：

import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class OptimizedPipeline {
    public static void main(String[] args) {
        ExecutorService readPool = Executors.newFixedThreadPool(2);
        ExecutorService processPool = Executors.newFixedThreadPool(20);
        ExecutorService writePool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 1000; i++) {
            CompletableFuture.supplyAsync(() -> {
                return UUID.randomUUID().toString();
            }, readPool).thenApplyAsync(r -> {
            	try {
                    Thread.sleep(10); // 模拟处理耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
				return r.toUpperCase();
            }, processPool).thenAcceptAsync(r -> {
            	System.out.println(r);
            }, writePool);
        }

        // 关闭线程池
        shutdownAndAwaitTermination(readPool, "readPool");
        shutdownAndAwaitTermination(processPool, "processPool");
        shutdownAndAwaitTermination(writePool, "writePool");
    }

    private static void shutdownAndAwaitTermination(ExecutorService pool, String poolName) {
        pool.shutdown();
        try {
            if (!pool.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS)) {
                pool.shutdownNow();
            }
        } catch (InterruptedException e) {
            pool.shutdownNow();
        }
        System.out.println(poolName + " has shutdown !!");
    }
}

优化点分析：

链式调用：通过thenAcceptAsync()实现任务的流水线处理，避免嵌套调用。
线程池分离：明确指定每个阶段的线程池，提高代码可读性。
异常处理：可以通过handle()方法统一处理异常。

4.2 线程池配置优化

区分CPU密集型和IO密集型任务：
- CPU密集型任务：线程数设置为CPU核心数 + 1。
- IO密集型任务：线程数设置为2 * CPU核心数。
使用有界队列：
- 通过ArrayBlockingQueue或LinkedBlockingQueue限制任务队列大小，防止内存溢出。
自定义拒绝策略：
- 通过RejectedExecutionHandler处理任务被拒绝的情况，例如记录日志或重试。