Кратко — суть, структура, когда применять, проблемы в многопоточности и реальная Java-реализация.
Что такое (суть)
- Паттерн Наблюдатель (Observer) обеспечивает рассылку уведомлений множеству заинтересованных объектов (наблюдателей) при изменении состояния субъекта (subject) — отделяет источник событий от обработчиков.
Структура (компоненты)
- Subject (Observable): хранит список Observer, предоставляет register/unregister/notify.
- Observer: интерфейс с методом update(...) (или onEvent(...)).
- ConcreteSubject: содержит состояние, вызывает notifyObservers() при изменениях.
- ConcreteObserver: реализует update, реагирует на события.
Простейший последовательный сценарий
- register(observer) → subject.changeState(...) → subject.notifyObservers() → для каждого observer вызов observer.update(state).
Когда использовать
- Когда нужно оповещать множество объектов об изменениях одного объекта.
- Когда важно слабое сцепление между источником событий и обработчиками.
- Реализация событийной модели (GUI), кэширования, реактивных потоков, pub/sub внутри одного процесса.
Проблемы и нюансы в многопоточном окружении и способы решения
- Состязания при доступе к списку наблюдателей (регистрация/удаление/уведомление) → использовать потокобезопасные структуры или синхронизацию.
- Потеря уведомлений / неконсистентное состояние: если subject изменяется одновременно с notify, наблюдатель может увидеть частичное состояние → делайте атомарные изменения состояния (synchronized / lock / volatile / immutable snapshot).
- Блокирующие или медленные наблюдатели: один медленный observer блокирует всех → вызывать observers асинхронно (ExecutorService) или отдельными задачами.
- Исключения в observer: одно исключение должно не прерывать рассылку остальным → оборачивать вызов каждого observer в try/catch.
- Утечки памяти: длительное хранение сильных ссылок на observers препятствует сбору → хранить WeakReference для слушателей, если это ожидаемое поведение.
- Порядок уведомлений: если важен порядок, выбирать структуру, гарантирующую порядок (например, CopyOnWriteArrayList сохраняет порядок регистрации).
- Производительность: notify делает $\mathcal{O}(n)$ вызовов (где $n$ — число наблюдателей), что может быть дорого при большом $n$.
- Взаимные блокировки: если observer в update вызывает методы subject, возможны deadlock при неправильном порядке блокировок → избегать долгих захватов lock при notify, использовать копию списка или не держать lock при вызовах внешних колбеков.
Рекомендации по реализации в многопоточности
- Для частых чтений и редких изменений списка observers: CopyOnWriteArrayList (нет внешней синхронизации, безопасно итерация во время модификаций).
- Для большого числа регистраций/удалений: ConcurrentLinkedQueue / ConcurrentHashMap + аккуратная итерация.
- Для асинхронных уведомлений: ExecutorService; для надежности — отдельный task на каждый observer с try/catch.
- Если нужно позволить сборку наблюдателей GC: хранить WeakReference и периодически чистить.
Вариант реализации на Java (синхронный безопасный + обработка ошибок + CopyOnWriteArrayList):
interface Observer {
void update(Object eventData);
}
interface Subject {
void register(Observer o);
void unregister(Observer o);
void notifyObservers(Object eventData);
}
import java.util.concurrent.CopyOnWriteArrayList;
class ConcreteSubject implements Subject {
private final CopyOnWriteArrayList observers = new CopyOnWriteArrayList();
private volatile Object state; // пример состояния
@Override
public void register(Observer o) {
observers.addIfAbsent(o);
}
@Override
public void unregister(Observer o) {
observers.remove(o);
}
public void setState(Object newState) {
this.state = newState;
notifyObservers(newState);
}
@Override
public void notifyObservers(Object eventData) {
for (Observer o : observers) {
try {
o.update(eventData);
} catch (RuntimeException ex) {
// логирование и продолжение рассылки
}
}
}
}
Пример асинхронного уведомления (каждому observer в отдельной задаче):
import java.util.concurrent.*;
class AsyncSubject implements Subject {
private final CopyOnWriteArrayList observers = new CopyOnWriteArrayList();
private final ExecutorService executor;
AsyncSubject(ExecutorService executor) {
this.executor = executor;
}
@Override
public void register(Observer o) { observers.addIfAbsent(o); }
@Override
public void unregister(Observer o) { observers.remove(o); }
@Override
public void notifyObservers(Object eventData) {
for (Observer o : observers) {
executor.submit(() -> {
try { o.update(eventData); }
catch (RuntimeException ex) { /* лог */ }
});
}
}
}
Дополнительные мелочи
- Для отмены утечек можно использовать WeakReference и при notify удалять собранные ссылки.
- Если важна консистентность состояния у всех наблюдателей, перед notify формируйте неизменяемый snapshot состояния и передавайте его.
Сводка
- Простая и мощная модель для рассылки событий с низкой связностью.
- В многопоточной среде нужно: безопасный контейнер для observers, защита состояния, обработка исключений, возможная асинхронность и использование слабых ссылок для предотвращения утечек памяти.