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

Java常见的并发设计模式

news 2025/3/13 18:46:04

1. 经典生产者-消费者模式

核心思想：生产者生产数据放入缓冲区，消费者从缓冲区取数据处理，二者通过阻塞队列（如 BlockingQueue）协调。
适用场景：消息队列、任务调度、数据处理管道。
实现方式：
- 使用 BlockingQueue（如 LinkedBlockingQueue）
- 使用 wait/notify
- 使用 Lock 和 Condition

示例：

class Producer implements Runnable {private BlockingQueue<Integer> queue;public Producer(BlockingQueue<Integer> queue) { this.queue = queue; }public void run() {try {while (true) {int item = new Random().nextInt(100);queue.put(item);  // 阻塞式放入System.out.println("生产：" + item);Thread.sleep(100);}} catch (InterruptedException e) { Thread.currentThread().interrupt(); }}
}class Consumer implements Runnable {private BlockingQueue<Integer> queue;public Consumer(BlockingQueue<Integer> queue) { this.queue = queue; }public void run() {try {while (true) {int item = queue.take();  // 阻塞式获取System.out.println("消费：" + item);Thread.sleep(200);}} catch (InterruptedException e) { Thread.currentThread().interrupt(); }}
}public class ProducerConsumerExample {public static void main(String[] args) {BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);new Thread(new Producer(queue)).start();new Thread(new Consumer(queue)).start();}
}

2. 观察者模式（Observer Pattern）

核心思想：一个对象（Subject）发生变化时，通知多个观察者（Observer）。
适用场景：事件驱动系统（如 GUI 事件监听、消息通知）。
实现方式：
- java.util.Observer（Java 9 之后被弃用）
- java.beans.PropertyChangeListener
- 自定义回调函数模式

示例：

interface Observer {void update(String message);
}class ConcreteObserver implements Observer {private String name;public ConcreteObserver(String name) { this.name = name; }public void update(String message) {System.out.println(name + " 收到消息: " + message);}
}class Subject {private List<Observer> observers = new ArrayList<>();public void addObserver(Observer observer) { observers.add(observer); }public void notifyObservers(String message) {for (Observer observer : observers) {observer.update(message);}}
}public class ObserverExample {public static void main(String[] args) {Subject subject = new Subject();Observer o1 = new ConcreteObserver("A");Observer o2 = new ConcreteObserver("B");subject.addObserver(o1);subject.addObserver(o2);subject.notifyObservers("新任务来了");}
}

3. 生产者-消费者-缓冲池模式（Producer-Consumer-Pool）

核心思想：在生产者和消费者之间加入一个线程池（如 ThreadPoolExecutor），用于处理任务，而不是直接由消费者消费。
适用场景：高吞吐任务处理，如 Web 服务器、日志处理。
实现方式：
- ExecutorService 线程池
- BlockingQueue

示例：

public class ThreadPoolProducerConsumer {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(3);BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);Runnable producer = () -> {try {while (true) {int item = new Random().nextInt(100);queue.put(item);System.out.println("生产：" + item);Thread.sleep(100);}} catch (InterruptedException e) { Thread.currentThread().interrupt(); }};Runnable consumer = () -> {try {while (true) {int item = queue.take();System.out.println("消费：" + item);Thread.sleep(200);}} catch (InterruptedException e) { Thread.currentThread().interrupt(); }};executor.execute(producer);executor.execute(consumer);executor.shutdown();}
}

4. 事件驱动架构（EDA - Event-Driven Architecture）

核心思想：生产者触发事件，消费者以异步方式处理事件。
适用场景：微服务架构、消息队列（Kafka、RabbitMQ）。
实现方式：
- CompletableFuture
- EventBus
- 消息队列（如 Kafka）

示例（CompletableFuture）：

import java.util.concurrent.*;public class EventDrivenExample {public static void main(String[] args) {CompletableFuture.runAsync(() -> {try {System.out.println("生产事件");Thread.sleep(1000);} catch (InterruptedException e) { e.printStackTrace(); }}).thenRun(() -> System.out.println("消费事件"));}
}

5. 责任链模式（Chain of Responsibility Pattern）

核心思想：多个处理者形成链条，依次处理请求，直到找到合适的处理者。
适用场景：日志处理、权限控制、请求过滤。
实现方式：
- 设计链式调用模式
- FilterChain 机制（如 Servlet 过滤器）

示例：

abstract class Handler {protected Handler next;public void setNext(Handler next) { this.next = next; }public abstract void handleRequest(int request);
}class ConcreteHandlerA extends Handler {public void handleRequest(int request) {if (request < 10) {System.out.println("A 处理请求: " + request);} else if (next != null) {next.handleRequest(request);}}
}class ConcreteHandlerB extends Handler {public void handleRequest(int request) {System.out.println("B 处理请求: " + request);}
}public class ChainExample {public static void main(String[] args) {Handler handlerA = new ConcreteHandlerA();Handler handlerB = new ConcreteHandlerB();handlerA.setNext(handlerB);handlerA.handleRequest(5);handlerA.handleRequest(15);}
}

总结

模式	适用场景	特点
生产者-消费者模式	任务队列	多线程并发控制
观察者模式	事件通知	低耦合，异步
生产者-消费者-缓冲池	高并发任务处理	使用线程池优化资源
事件驱动架构（EDA）	微服务，消息驱动	异步，解耦
责任链模式	过滤器，权限控制	链式调用