Кратко о паттерне
- Наблюдатель (Observer) — поведенческий паттерн, где один объект (Subject / Observable) поддерживает список наблюдателей (Observers) и уведомляет их об изменениях состояния.
- Роли: Subject — регистрирует/удаляет наблюдателей и вызывает notify; Observer — реализует метод (например, update), который вызывается при изменениях.
- Push vs Pull: push — Subject передаёт данные при notify; pull — Observer запрашивает данные у Subject при получении уведомления.
- В GUI часто предпочтителен pull (Observer читает из модели), но push удобен для простых уведомлений.
Проблемы циклических ссылок и решение
- Если Subject держит сильные ссылки на Observer и Observer держит ссылку на Subject, может возникнуть цикл, препятствующий сбору мусора (особенно если есть __del__).
- Решение: Subject хранит слабые ссылки на наблюдателей (weakref). Если Observer держит ссылку на Subject, лучше тоже сделать её слабой (weakref.ref) или корректно отписываться при уничтожении/закрытии.
Реализация в Python (подходит для GUI)
- Используем weakref для безопасного хранения наблюдателей.
- Поддерживаем как обычные функции, так и bound-методы экземпляров.
- Автоматически удаляем "уже собранные" наблюдатели при notify.
Пример реализации:
```python
import weakref
import types
class WeakCallback:
"""
Универсальная слабая ссылка на callback: поддерживает функции и bound-методы.
Сравнение и хеширование основаны на (объекте, функция) или на самой функции.
"""
def __init__(self, callback):
if hasattr(callback, "__self__") and callback.__self__ is not None:
# bound method
self._self_ref = weakref.ref(callback.__self__)
self._func = callback.__func__
else:
# function or staticmethod
self._self_ref = None
self._func = callback
def __call__(self):
if self._self_ref is None:
return self._func # обычная функция
obj = self._self_ref()
if obj is None:
return None
return types.MethodType(self._func, obj)
def alive(self):
return self() is not None
def __eq__(self, other):
if not isinstance(other, WeakCallback):
return False
if self._self_ref is None and other._self_ref is None:
return self._func == other._func
return (self._self_ref() is not None and other._self_ref() is not None
and self._self_ref() is other._self_ref()
and self._func == other._func)
def __hash__(self):
if self._self_ref is None:
return hash(self._func)
obj = self._self_ref()
return hash((id(obj) if obj is not None else None, self._func))
class Subject:
def __init__(self):
self._observers = set()
def attach(self, callback):
"""callback: функция или bound-метод (например, observer.update)."""
self._observers.add(WeakCallback(callback))
def detach(self, callback):
self._observers.discard(WeakCallback(callback))
def notify(self, *args, **kwargs):
dead = set()
for wc in tuple(self._observers):
func = wc()
if func is None:
dead.add(wc)
else:
try:
func(*args, **kwargs)
except TypeError:
# Совместимость: если подписчик ожидает (subject, ...)
try:
func(self, *args, **kwargs)
except Exception:
raise
self._observers -= dead
```
Простой GUI-пример с tkinter (Model — Subject, View — Observer):
```python
import tkinter as tk
import weakref
class Model(Subject):
def __init__(self):
super().__init__()
self._value = 0
@property
def value(self):
return self._value
def increment(self):
self._value += 1
self.notify() # pull: observers прочитают model.value
class View(tk.Frame):
def __init__(self, master, model):
super().__init__(master)
self.pack()
# Держим слабую ссылку на модель, чтобы не создавать цикл
self._model_ref = weakref.ref(model)
self.label = tk.Label(self, text="0")
self.label.pack()
btn = tk.Button(self, text="Inc", command=self.on_inc)
btn.pack()
# Подписываемся на изменения модели
model.attach(self.update)
# при закрытии окна желательно отписываться:
master.protocol("WM_DELETE_WINDOW", self.on_close)
def on_inc(self):
model = self._model_ref()
if model:
model.increment()
def update(self):
model = self._model_ref()
if model:
self.label.config(text=str(model.value))
def on_close(self):
model = self._model_ref()
if model:
model.detach(self.update)
self.master.destroy()
if __name__ == "__main__":
root = tk.Tk()
model = Model()
view = View(root, model)
root.mainloop()
```
Ключевые замечания и лучшие практики
- Subject хранит наблюдателей слабо — это уменьшает риск утечек.
- Если Observer хранит ссылку на Subject, используйте weakref.ref или явное detach при уничтожении/закрытии.
- В многопоточных GUI (если модель обновляется из другого потока) — синхронизируйте доступ и уведомления; в GUI-фреймворках обычно обновления UI должны выполняться в основном (GUI) потоке.
- При массовых или частых уведомлениях думайте о дебаунсе/пакетировании событий, чтобы не перегружать UI.
Этого достаточно для корректной, безопасной реализации паттерна Observer в GUI-приложении с учётом слабых ссылок и проблем циклических ссылок.