Java 多线程在项目中的常见应用场景

// 使用并行流计算总和
long sum = LongStream.rangeClosed(1, 10_000_000)
    .parallel()
    .sum();

// 手动分片
List<List<Data>> partitions = partition(dataList, 1000);
List<CompletableFuture<Result>> futures = partitions.stream()
    .map(partition -> CompletableFuture.supplyAsync(() -> process(partition), executor))
    .collect(Collectors.toList());
List<Result> results = futures.stream().map(CompletableFuture::join).collect(Collectors.toList());

3.3 注意事项

• 数据竞争：确保分片独立，避免共享可变状态。
• 任务粒度：分片不宜过细，否则线程调度开销可能超过计算收益。
• CPU 密集型 vs IO 密集型：并行计算适合 CPU 密集型任务，线程数通常设置为 CPU 核心数 +1。

4. 高并发服务器：处理海量请求

4.1 场景描述

Web 容器（如 Tomcat）为每个请求分配一个线程，从而实现并发处理。NIO 模型也依赖线程池管理连接。此外，RPC 框架（如 Dubbo）的服务端和客户端也大量使用线程池处理网络事件。

4.2 实现方案

• 传统 BIO 模型：一个线程处理一个连接，连接数受限于线程数。
• NIO 模型：少量线程处理大量连接（如 Netty 的 EventLoop）。
• 业务处理线程池：在 Controller 层将耗时业务提交给业务线程池，避免阻塞容器线程。

# Spring Boot 默认使用 Tomcat，可配置最大线程数
server.tomcat.max-threads=200
server.tomcat.max-connections=10000

4.3 注意事项

• 线程池饱和策略：当请求超过处理能力时，需合理选择拒绝策略（如丢弃、调用者运行）。
• 上下文切换：线程过多会导致频繁切换，降低吞吐量。
• 异步 Servlet：Spring WebFlux 提供了响应式编程模型，进一步提升并发能力。

5. 定时任务：后台调度执行

5.1 场景描述

系统需要定期执行某些任务，如每天凌晨统计数据、每小时清理临时文件、每分钟检查超时订单。这些任务通常由调度线程池执行。

5.2 实现方案

• ScheduledThreadPoolExecutor：Java 提供的定时线程池。
• Quartz：功能强大的开源调度框架。
• Spring @Scheduled：基于注解的定时任务，底层使用 ScheduledThreadPoolExecutor。

@Scheduled(cron = "0 0 1 * * ?") // 每天凌晨 1 点执行
public void generateReport() {
    // 生成日报
}

5.3 注意事项

• 任务执行时间重叠：如果任务执行时间超过周期，需考虑是否允许并发执行（使用 @Scheduled(fixedDelay) 避免重叠）。
• 异常处理：定时任务中的未捕获异常会导致后续任务不再执行（ScheduledThreadPoolExecutor 会吞掉异常，需自行捕获）。
• 分布式调度：在集群环境中，需确保同一任务只在一个节点执行，可引入分布式调度框架（如 XXL-JOB）。

6. 数据库连接池：管理并发连接

6.1 场景描述

数据库连接是稀缺资源，频繁创建/关闭开销大。连接池（如 HikariCP、Druid）维护一组连接，允许多个线程并发获取和释放连接。

6.2 实现方案

连接池内部使用线程安全的集合（如 ConcurrentLinkedQueue、LinkedBlockingQueue）管理连接。线程通过 getConnection() 获取连接，使用后 close() 归还。

// HikariCP 配置示例
HikariConfig config = new HikariConfig();
config.setMaximumPoolSize(20);
config.setMinimumIdle(5);
HikariDataSource dataSource = new HikariDataSource(config);

6.3 注意事项

• 连接泄漏：必须确保在 finally 块中释放连接，否则连接池资源耗尽。
• 超时设置：合理配置连接超时、空闲超时，避免连接被长时间占用。
• 动态调整：根据并发压力监控并调整连接池大小。

7. 消息队列消费：并发处理消息

7.1 场景描述

消息中间件（如 Kafka、RabbitMQ）通常支持多线程消费，以提高处理速度。每个消费者可以启动多个线程处理不同分区或消息。

7.2 实现方案

• 多线程拉取：每个线程拉取一批消息并行处理。
• 线程池处理：消息监听器将消息提交给线程池，实现异步处理。

@KafkaListener(topics = "orders", concurrency = "3") // 启动 3 个消费者线程
public void consume(Order order) {
    // 处理订单
}

7.3 注意事项

• 顺序保证：如果需要保证消息顺序，需确保同一分区的消息由同一线程处理。
• 手动提交偏移量：使用手动提交时，需确保处理完成后提交，避免重复消费。
• 幂等性：消息处理需设计为幂等，防止重复消费导致数据不一致。

8. 文件处理：并发读写与传输

8.1 场景描述

• 多文件上传/下载：用户同时上传多个文件，或系统需要批量下载文件打包成 ZIP。
• 大文件分片处理：将大文件分片，多线程分别处理（如计算 MD5、压缩）。
• 日志收集：多个线程同时写入日志文件（需使用线程安全的 Appender，如 Logback 的 AsyncAppender）。

8.2 实现方案

• 线程池处理多个文件：每个文件提交一个任务。
• 分片处理：使用 RandomAccessFile 或 NIO 的 FileChannel，每个线程负责一段范围。
• 异步日志：使用异步日志框架减少 I/O 阻塞。

// 分片计算文件 MD5
ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<byte[]>> futures = new ArrayList<>();
for (int i = 0; i < 4; i++) {
    long start = i * chunkSize;
    long end = Math.min(start + chunkSize, fileSize);
    futures.add(executor.submit(() -> computeChunkMD5(file, start, end)));
}

8.3 注意事项

• 磁盘 I/O 竞争：多线程读写同一磁盘可能造成寻道时间增加，反而变慢。SSD 相对好些。
• 文件锁：需要互斥访问时，可使用 FileLock 或同步机制。
• 内存使用：分片处理需控制缓冲区大小，避免 OOM。

9. 缓存更新：多线程加载与失效

9.1 场景描述

在高并发系统中，缓存（如 Redis、本地 Caffeine）失效时，若大量请求同时穿透到数据库，可能导致数据库压力暴增（缓存雪崩）。多线程加载是一种常见解决方案：当缓存失效时，只允许一个线程去加载数据，其他线程等待。

9.2 实现方案

• 互斥锁：使用分布式锁（如 Redis 的 SETNX）或本地锁（如 synchronized、ReentrantLock）控制只有一个线程加载。
• Future 模式：使用 Future 缓存加载任务，后续线程等待同一个 Future 的结果。

// 使用 ConcurrentHashMap 缓存 Future
ConcurrentHashMap<String, Future<Object>> cache = new ConcurrentHashMap<>();

public Object getData(String key) {
    Future<Object> future = cache.get(key);
    if (future == null) {
        FutureTask<Object> task = new FutureTask<>(() -> loadFromDB(key));
        future = cache.putIfAbsent(key, task);
        if (future == null) {
            future = task;
            task.run(); // 执行加载
        }
    }
    return future.get(); // 等待结果
}

9.3 注意事项

• 防止死锁：避免在加载过程中再次获取同一锁。
• 超时处理：加载失败时需移除 Future，允许后续线程重试。
• 缓存穿透：即使数据不存在，也缓存空值，避免每次穿透。

10. 批处理：大规模数据操作

10.1 场景描述

ETL 任务、数据迁移、报表生成等场景需要处理数百万甚至数亿条记录。单线程处理耗时过长，多线程分片处理可以显著缩短时间。

10.2 实现方案

• 分页查询 + 多线程处理：每个线程处理一页数据，使用线程池并行执行。
• MapReduce 思想：拆分任务、并行处理、合并结果。
• 使用框架：Spring Batch 支持多线程 Step（TaskExecutorStep）。

// 多线程数据迁移
int totalCount = countRecords();
int pageSize = 1000;
int threadCount = 10;
int pagesPerThread = totalCount / (pageSize * threadCount);
ExecutorService executor = Executors.newFixedThreadPool(threadCount);
for (int i = 0; i < threadCount; i++) {
    int startPage = i * pagesPerThread;
    executor.submit(() -> migratePage(startPage, pageSize));
}

10.3 注意事项

• 事务管理：多线程操作通常不在同一个事务中，需保证最终一致性，或使用分布式事务。
• 数据库连接数：每个线程需要独立的数据库连接，需配置足够的连接池大小。
• 资源隔离：避免多个批处理任务互相影响，可考虑独立线程池。

11. 图形界面编程：避免 UI 卡顿

11.1 场景描述

Swing、JavaFX 等桌面应用，如果在事件调度线程（EDT）中执行耗时操作（如网络请求、文件读写），界面会冻结。需要将耗时操作放到后台线程，完成后更新 UI。

11.2 实现方案

• SwingWorker：Swing 提供的后台任务工具，可在 doInBackground() 中执行耗时操作，通过 publish()/process() 更新 UI。
• JavaFX Task：类似 SwingWorker，在 call() 中执行任务，使用 Platform.runLater() 更新 UI。

// JavaFX 示例
Task<Void> task = new Task<>() {
    @Override
    protected Void call() throws Exception {
        // 耗时操作
        return null;
    }
};
new Thread(task).start();

11.3 注意事项

• UI 更新必须在 EDT：Java UI 框架要求所有 UI 操作在特定线程执行。
• 线程中断：后台任务应响应中断，以便用户取消操作。
• 避免死锁：不要从后台线程调用 UI 同步方法。

12. 分布式系统中的多线程

12.1 场景描述

在微服务架构中，一个服务可能需要调用多个下游服务。如果串行调用，总耗时等于各服务耗时之和。使用多线程并行调用可以大幅降低延迟。

12.2 实现方案

• CompletableFuture 组合：同时发起多个远程调用，等待所有结果返回。
• 线程池隔离：为不同下游服务配置独立的线程池，防止某个服务慢导致线程池耗尽。

CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> userService.getUser(id), userPool);
CompletableFuture<Order> orderFuture = CompletableFuture.supplyAsync(() -> orderService.getOrder(id), orderPool);
CompletableFuture<Void> all = CompletableFuture.allOf(userFuture, orderFuture);
all.join(); // 等待两个都完成
User user = userFuture.get();
Order order = orderFuture.get();

12.3 注意事项

• 超时控制：为每个异步任务设置超时，避免一直等待。
• 链路追踪：多线程环境下需传递 Trace ID，以便日志串联。
• 线程上下文传递：如 Spring Security 的 SecurityContext，需手动传递（使用 ThreadLocal 的继承性或 TransmittableThreadLocal）。

13. 多线程设计模式

13.1 生产者 - 消费者模式

• 场景：日志收集、消息队列、任务队列。生产者产生数据，消费者处理数据，中间通过阻塞队列解耦。
• Java 实现：BlockingQueue（如 ArrayBlockingQueue、LinkedBlockingQueue）。

BlockingQueue<Task> queue = new LinkedBlockingQueue<>(100);
// 生产者
new Thread(() -> {
    while (true) {
        Task task = createTask();
        queue.put(task);
    }
}).start();
// 消费者
new Thread(() -> {
    while (true) {
        Task task = queue.take();
        process(task);
    }
}).start();

13.2 工作线程模式（线程池）

• 场景：避免频繁创建销毁线程，复用线程处理多个任务。
• Java 实现：ThreadPoolExecutor。

13.3 Future 模式

• 场景：提交一个任务后立即返回 Future，稍后获取结果，实现异步调用。
• Java 实现：FutureTask、CompletableFuture。

13.4 读写锁模式

• 场景：读多写少的共享数据访问，允许多个读线程同时访问，写线程独占。
• Java 实现：ReentrantReadWriteLock、StampedLock。

14. 并发工具类的实际应用

14.1 CountDownLatch：等待多个线程完成

• 场景：主线程等待所有子任务完成后再继续，如并行计算合并结果。

CountDownLatch latch = new CountDownLatch(10);
for (int i = 0; i < 10; i++) {
    executor.submit(() -> {
        try {
            doWork();
        } finally {
            latch.countDown();
        }
    });
}
latch.await(); // 等待所有任务完成

14.2 CyclicBarrier：线程相互等待到某个屏障

• 场景：多步计算，每一步需要所有线程都完成才能进入下一步。

14.3 Semaphore：限流控制

• 场景：控制同时访问某个资源的线程数，如数据库连接池限制。

Semaphore semaphore = new Semaphore(10); // 允许 10 个线程同时访问
semaphore.acquire();
try {
    accessResource();
} finally {
    semaphore.release();
}

14.4 Exchanger：线程间交换数据

• 场景：两个线程交换数据，如生产者 - 消费者交换缓冲区。

15. 现代 Java 并发 API

15.1 CompletableFuture

• 提供了函数式编程风格的异步组合，支持 thenApply、thenCombine、exceptionally 等，极大简化了异步编程。

15.2 并行流

• 内部使用 ForkJoinPool，适用于集合的并行操作，但需注意共享可变状态。

15.3 StampedLock

• 乐观读锁，适用于读多写少且读操作无副作用的高并发场景，性能优于 ReentrantReadWriteLock。

15.4 Phaser

• 可重用的同步屏障，替代 CountDownLatch 和 CyclicBarrier，支持动态注册线程。

16. 多线程编程注意事项

16.1 线程安全

• 使用 synchronized、Lock、原子类、并发集合（ConcurrentHashMap、CopyOnWriteArrayList）确保共享数据安全。

16.2 死锁预防

• 避免嵌套锁，使用定时锁（tryLock），保持锁顺序一致。

16.3 线程池配置

• 根据任务类型（CPU 密集型/IO 密集型）合理设置线程池参数。
• 使用有界队列防止内存溢出。
• 自定义拒绝策略。

16.4 上下文切换开销

• 线程数并非越多越好，需通过压测找到最佳并发度。

16.5 异常处理

• 线程内未捕获异常会导致线程终止，需设置 UncaughtExceptionHandler 或使用 Future 的 get() 捕获。

16.6 线程本地变量（ThreadLocal）

• 用于线程内共享数据，如请求上下文、数据库连接。注意使用后及时清理，避免内存泄漏。

17. 实战案例分析

17.1 电商秒杀系统

• 使用线程池处理瞬时高并发请求，通过限流（Semaphore）、缓存、异步削峰。

17.2 大数据报表系统

• 多线程分片查询数据库，并行计算指标，最后合并生成 Excel。

17.3 微服务网关

• 使用异步非阻塞模型（Netty）处理大量连接，业务逻辑通过线程池隔离。

18. 总结

Java 多线程在项目中的应用无处不在，从后端服务到客户端应用，从异步处理到并行计算，每一个场景都需要深入理解并发原理并谨慎设计。