当前位置：首页 > news >正文

Java并发编程实战 Day 11：并发设计模式

news 来源：原创 2025/6/7 10:02:55

【Java并发编程实战 Day 11】并发设计模式

开篇

这是"Java并发编程实战"系列的第11天，今天我们聚焦于并发设计模式。并发设计模式是解决多线程环境下常见问题的经典解决方案，它们不仅提供了优雅的设计思路，还能显著提升系统的性能和可靠性。本文将深入探讨三种核心的并发设计模式：生产者-消费者模式、读写锁模式以及线程本地存储（ThreadLocal）模式。通过理论分析、代码实践和性能测试，我们将全面掌握这些模式的应用场景和实现原理。

理论基础

并发设计模式概述

并发设计模式是专门为解决多线程环境下的特定问题而设计的模板化解决方案。它们通常结合了锁机制、线程间通信和资源共享等技术，帮助开发者以更高效、更安全的方式实现并发程序。以下是三种常见的并发设计模式：

1. 生产者-消费者模式

生产者-消费者模式是一种经典的线程协作模式，用于解耦生产数据和消费数据的过程。通过共享队列，生产者线程将数据放入队列，消费者线程从队列中取出数据处理。这种模式能够有效平衡生产和消费的速度差异，避免资源浪费或饥饿现象。

2. 读写锁模式

读写锁模式是一种优化的锁机制，允许多个线程同时读取共享资源，但写操作需要独占锁。相比传统的互斥锁，读写锁在读多写少的场景下具有更高的并发性能。

3. 线程本地存储（ThreadLocal）

ThreadLocal为每个线程提供独立的变量副本，避免了线程间的竞争条件。它常用于线程上下文传递、数据库连接管理等场景。

适用场景

场景描述与问题分析

生产者-消费者模式
- 场景：消息队列系统中，生产者不断生成消息，消费者按需处理消息。
- 问题：生产速度和消费速度不一致，可能导致内存溢出或资源浪费。
读写锁模式
- 场景：缓存系统中，多个线程频繁读取数据，但偶尔需要更新数据。
- 问题：传统互斥锁会导致读操作阻塞，降低系统吞吐量。
线程本地存储
- 场景：Web应用中，每个请求需要独立的数据库连接。
- 问题：全局共享连接池可能导致线程间冲突。

代码实践

生产者-消费者模式

以下是一个基于BlockingQueue的生产者-消费者实现：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;public class ProducerConsumerExample {private static final int QUEUE_CAPACITY = 5;private static BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(QUEUE_CAPACITY);public static void main(String[] args) {Thread producer = new Thread(() -> {try {for (int i = 0; i < 10; i++) {System.out.println("Producing: " + i);queue.put(i); // 阻塞直到队列有空位Thread.sleep(100); // 模拟生产耗时}} catch (InterruptedException e) {Thread.currentThread().interrupt();}});Thread consumer = new Thread(() -> {try {while (true) {Integer value = queue.take(); // 阻塞直到队列有数据System.out.println("Consuming: " + value);Thread.sleep(200); // 模拟消费耗时}} catch (InterruptedException e) {Thread.currentThread().interrupt();}});producer.start();consumer.start();}
}

读写锁模式

使用ReentrantReadWriteLock实现读写锁：

import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReadWriteLockExample {private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();private int sharedResource = 0;public void readResource() {lock.readLock().lock();try {System.out.println("Reading resource: " + sharedResource);} finally {lock.readLock().unlock();}}public void writeResource(int value) {lock.writeLock().lock();try {sharedResource = value;System.out.println("Writing resource: " + sharedResource);} finally {lock.writeLock().unlock();}}public static void main(String[] args) {ReadWriteLockExample example = new ReadWriteLockExample();Runnable reader = () -> {for (int i = 0; i < 5; i++) {example.readResource();try {Thread.sleep(100);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}};Runnable writer = () -> {for (int i = 0; i < 5; i++) {example.writeResource(i);try {Thread.sleep(200);} catch (InterruptedException e) {Thread.currentThread().interrupt();}}};new Thread(reader).start();new Thread(writer).start();}
}

线程本地存储

使用ThreadLocal管理线程上下文：

public class ThreadLocalExample {private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);public static void main(String[] args) {Runnable task = () -> {int value = threadLocal.get();value += 1;threadLocal.set(value);System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());};Thread t1 = new Thread(task);Thread t2 = new Thread(task);t1.start();t2.start();}
}