Java Observer模式如何确保线程安全

在Java中，Observer模式是一种行为设计模式，它允许对象（称为观察者）订阅并响应另一个对象（称为主题）的事件。为了确保线程安全，可以采取以下几种策略：

1. 使用线程安全的集合类：在实现Subject时，使用线程安全的集合类来存储观察者列表。例如，可以使用CopyOnWriteArrayList或ConcurrentHashMap来存储观察者。

import java.util.concurrent.CopyOnWriteArrayList;

public class Subject {
    private final CopyOnWriteArrayList<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. 同步访问观察者列表：在添加、删除和通知观察者的方法上使用synchronized关键字来确保线程安全。

public class Subject {
    private final List<Observer> observers = new ArrayList<>();

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

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

    public synchronized void notifyObservers() {
        List<Observer> observersCopy;
        synchronized (this) {
            observersCopy = new ArrayList<>(observers);
        }
        for (Observer observer : observersCopy) {
            observer.update();
        }
    }
}

3. 使用原子操作：在添加和删除观察者时，使用原子操作来确保线程安全。

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.CopyOnWriteArrayList;

public class Subject {
    private final CopyOnWriteArrayList<Observer> observers = new CopyOnWriteArrayList<>();
    private final AtomicInteger observerCount = new AtomicInteger(0);

    public void addObserver(Observer observer) {
        int count;
        do {
            count = observerCount.get();
        } while (!observerCount.compareAndSet(count, count + 1));
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        int count;
        do {
            count = observerCount.get();
        } while (!observerCount.compareAndSet(count, count - 1));
        observers.remove(observer);
    }

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

4. 使用锁：在添加、删除和通知观察者的方法上使用显式锁（如ReentrantLock）来确保线程安全。

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Subject {
    private final List<Observer> observers = new ArrayList<>();
    private final Lock lock = new ReentrantLock();

    public void addObserver(Observer observer) {
        lock.lock();
        try {
            observers.add(observer);
        } finally {
            lock.unlock();
        }
    }

    public void removeObserver(Observer observer) {
        lock.lock();
        try {
            observers.remove(observer);
        } finally {
            lock.unlock();
        }
    }

    public void notifyObservers() {
        lock.lock();
        try {
            for (Observer observer : observers) {
                observer.update();
            }
        } finally {
            lock.unlock();
        }
    }
}

总之，确保Observer模式的线程安全需要在实现Subject时考虑并发访问观察者列表的情况。可以选择使用线程安全的集合类、同步访问、原子操作或锁来实现线程安全。