Java常见的并发设计模式

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);
    }
}

总结

如果你是做 高并发系统、微服务、消息队列，可以考虑 事件驱动 和 生产者-消费者模式。如果是 GUI 事件、回调机制，观察者模式 更适用。