Java Observer模式在多线程环境下的应用

在多线程环境下使用Java的观察者模式（Observer Pattern）时，需要特别注意线程安全问题。观察者模式是一种行为设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

以下是在多线程环境下使用观察者模式的一些关键点和示例代码：

1. 线程安全的观察者列表

首先，确保观察者列表是线程安全的。可以使用CopyOnWriteArrayList来存储观察者，因为它在添加或删除元素时会创建一个新的副本，从而避免并发修改异常。

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class Observable {
    private List<Observer> observers = new CopyOnWriteArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

2. 线程安全的观察者更新

在通知观察者时，确保每个观察者的update方法是线程安全的。如果update方法中涉及到共享资源的修改，需要使用同步机制（如synchronized关键字或Lock接口）来保证线程安全。

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    private final String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public synchronized void update() {
        // 线程安全的操作
        System.out.println(name + " received update at " + System.currentTimeMillis());
    }
}

3. 使用线程池

如果观察者的update方法需要执行耗时操作，可以考虑使用线程池来异步执行这些操作，从而避免阻塞主线程。

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

public class Observable {
    private List<Observer> observers = new CopyOnWriteArrayList<>();
    private ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            executorService.submit(() -> observer.update());
        }
    }

    public void shutdown() {
        executorService.shutdown();
    }
}

4. 示例代码

以下是一个完整的示例，展示了如何在多线程环境下使用观察者模式：

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ObserverPatternExample {
    public static void main(String[] args) {
        Observable observable = new Observable();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        observable.addObserver(observer1);
        observable.addObserver(observer2);

        // 模拟多线程环境下的通知
        for (int i = 0; i < 5; i++) {
            new Thread(() -> observable.notifyObservers()).start();
        }

        // 关闭线程池
        observable.shutdown();
    }
}

class Observable {
    private List<Observer> observers = new CopyOnWriteArrayList<>();
    private ExecutorService executorService = Executors.newFixedThreadPool(10);

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : observers) {
            executorService.submit(() -> observer.update());
        }
    }

    public void shutdown() {
        executorService.shutdown();
    }
}

interface Observer {
    void update();
}

class ConcreteObserver implements Observer {
    private final String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    @Override
    public synchronized void update() {
        System.out.println(name + " received update at " + System.currentTimeMillis());
    }
}

通过以上方法，可以在多线程环境下安全地使用观察者模式，确保观察者的通知和更新操作是线程安全的。