Czytaj książkę: «Одиночка. Паттерн GoF на Python, C++23, Rust и Java»

Czcionka:

Введение

Эта книга посвящена одному паттерну проектирования — Одиночка (Singleton). Он относится к каталогу «Банды четырёх» (Gang of Four, GoF). Здесь паттерн разобран сразу в четырёх реализациях: на Python, C++23, Rust и Java. Каждая реализация — отдельная часть книги: сначала задача и общая схема, затем код, модификации, гибридные варианты и самостоятельные работы.

Как читать

Основы каждого языка здесь не повторяются: они собраны в книгах серий по соответствующему языку. Разделы каждой части нумеруются заново, поэтому ссылка «раздел 1.2» указывает на раздел той же части, где она сделана.

Глава 5. Реализация на Python

5.1. Что ограничивает паттерн

Одиночка гарантирует, что у класса есть ровно один экземпляр, и даёт к нему глобальную точку доступа: журнал событий, конфигурация, реестр плагинов, пул соединений.

Перед реализацией нужно определить область единственности: «один на процесс», «один на поток», «один на тест». И отделить два решения: единственность экземпляра — свойство задачи, а глобальный доступ — удобство, за которое платят тестируемостью.

В Python у одиночки есть особенность: модуль уже является одиночкой. Модуль выполняется один раз при первом импорте и кэшируется в sys.modules; все последующие import возвращают тот же объект. Поэтому в идиоматичном Python одиночку часто вообще не пишут как класс — достаточно объекта на уровне модуля. Классические реализации тоже существуют, и их полезно знать, чтобы понимать чужой код и выбирать осознанно.

5.2. Участники и схема



Singleton — класс с единственным экземпляром.

Точка доступа — конструктор, функция или атрибут модуля, всегда возвращающие один объект.

5.3. Модуль как одиночка

Файл 01_module.py :




Листинг 5.1 — Модуль как одиночка

Разбор. Чтобы пример поместился в один файл, модуль settings создан вручную и записан в sys.modules — ровно так поступает механизм импорта. В реальном проекте это был бы обычный файл settings.py. Код модуля выполнился один раз, а оба import вернули один объект. Изменение, сделанное через одну ссылку, видно через другую.

Для большинства задач — конфигурация, реестры, общие ресурсы — этого достаточно. Модуль даёт единственность, ленивую загрузку (при первом импорте) и понятную точку доступа.

5.4. Классическая реализация через new

Если нужен именно класс — например, чтобы наследоваться или передавать объект туда, где ожидается экземпляр, — единственность обеспечивают в __new__.

Файл 02_new.py :




Листинг 5.2 — Классическая реализация через __new__

Разбор. __new__ создаёт объект, __init__ его настраивает. Переопределив __new__, класс возвращает уже существующий экземпляр. Инициализация атрибутов перенесена в __new__, а не в __init__: __init__ вызывался бы при каждом Logger() и сбрасывал бы список.

Двойная проверка: первая без блокировки — быстрый путь, когда экземпляр уже есть; вторая под блокировкой — защита от ситуации, когда два потока одновременно прошли первую проверку. Восемь потоков создали журнал ровно один раз.

5.5. Разновидности

Ленивая функция с кэшем

Самый короткий способ получить «одиночку с ленивой инициализацией» — функция с functools.cache.

Файл 03_cache.py :



Листинг 5.3 — Разновидности

Разбор. @cache запоминает результат вызова функции без аргументов, поэтому объект создаётся при первом обращении и затем возвращается тот же. Плюс по сравнению с классом-одиночкой — cache_clear() позволяет сбросить состояние в тестах. Функция с кэшем потокобезопасна в том смысле, что не повредит свою структуру, но при одновременном первом вызове из двух потоков функция может выполниться дважды; если это недопустимо, нужна блокировка, как в __new__.

Борг: общее состояние вместо единственного объекта

Файл 04_borg.py :




Листинг 5.4 — Разновидности

Разбор. Паттерн «Борг» (Monostate) — питоновская альтернатива одиночке: объектов может быть сколько угодно, но все они разделяют один словарь атрибутов. Для вызывающего кода разница почти незаметна. setdefault задаёт значение по умолчанию, только если его ещё нет, иначе каждое создание сбрасывало бы тему.

Одиночка на поток

Файл 05_thread_local.py :




Листинг 5.5 — Разновидности

Разбор. threading.local() — объект, атрибуты которого у каждого потока свои. Синхронизация не нужна. Так хранят соединения с базой, текущего пользователя запроса, буферы. В асинхронном коде вместо этого используют contextvars.ContextVar, потому что в одном потоке выполняется много задач.

5.6. Гибрид: атомарный генератор идентификаторов

Файл 06_ids.py :



Листинг 5.6 — Гибрид: атомарный генератор идентификаторов

Разбор. Объект ids создан на уровне модуля — это и есть одиночка в идиоматичном стиле: все, кто импортирует модуль, получают один генератор. Вызов next() у itertools.count в CPython фактически атомарен, но полагаться на это — деталь реализации; блокировка делает гарантию явной и переносимой на другие реализации Python.

5.7. Альтернатива одиночке: внедрение зависимостей

Часто лучший одиночка — тот, которого нет: объект создаётся один раз в точке входа программы и передаётся явно.

Файл 07_injection.py :




Листинг 5.7 — Альтернатива одиночке: внедрение зависимостей




Листинг 5.7 (продолжение) — Альтернатива одиночке: внедрение зависимостей

Разбор. Приложение получает часы и хранилище параметрами. Единственность обеспечивается тем, что main создаёт по одному экземпляру, а зависимости видны в сигнатуре App. В тестах подставляются свои часы и хранилище, и параллельные тесты не мешают друг другу.

5.8. Самостоятельная работа: кэш курсов валют

Задание. Сделайте одиночку-кэш курсов: при первом обращении он «загружает» курсы, потом отдаёт их без повторной загрузки; курсы можно обновлять из любого потока. Проверьте, что загрузка выполнилась один раз при одновременном обращении восьми потоков.

Полное решение — файл 08_rates.py :




Листинг 5.8 — Самостоятельная работа: кэш курсов валют




Листинг 5.8 (продолжение) — Самостоятельная работа: кэш курсов валют

Разбор. Точка доступа — метод класса instance(), а не конструктор: так Rates() остаётся обычным конструктором, который можно вызвать в тестах, а программа пользуется общим экземпляром. Медленная загрузка (sleep) делает гонку вероятной: без блокировки несколько потоков успели бы начать загрузку одновременно.

5.9. Типичные ошибки

Инициализация в __init__ у одиночки через __new__. __init__ вызывается при каждом Logger() и сбрасывает состояние.

Одиночка вместо параметра. Если объект нужен в трёх функциях, передайте его параметром.

Глобальное изменяемое состояние без блокировки. Модуль-одиночка с изменяемыми данными, разделяемый потоками, требует синхронизации.

Невозможность сбросить состояние в тестах. Предусмотрите сброс (cache_clear, отдельный конструктор) или используйте внедрение зависимостей.

5.10. Вопросы для самопроверки

Почему модуль в Python уже является одиночкой?

Зачем при реализации через __new__ атрибуты инициализируют в __new__, а не в __init__?

Что такое двойная проверка и зачем она нужна?

Чем удобна функция с @cache по сравнению с классом-одиночкой?

Чем «Борг» отличается от одиночки?

Когда нужен threading.local, а когда contextvars.ContextVar?

Почему блокировка в генераторе идентификаторов полезна, хотя next(count) в CPython атомарен?

Как внедрение зависимостей обеспечивает единственность без глобального доступа?

5.11. Ответы

Код модуля выполняется один раз при первом импорте, а модуль кэшируется в sys.modules; все импорты возвращают один объект.

__init__ вызывается при каждом обращении к конструктору и сбросил бы состояние.

Первая проверка без блокировки — быстрый путь; вторая под блокировкой — защита от одновременного создания двумя потоками, прошедшими первую проверку.

Ленивое создание одной строкой и сброс через cache_clear() в тестах.

Экземпляров может быть много, но все разделяют одно состояние.

threading.local — когда каждому потоку нужен свой экземпляр. ContextVar — в асинхронном коде, где в одном потоке выполняется много задач.

Атомарность — деталь реализации CPython; блокировка делает гарантию явной и переносимой.

Экземпляр создаётся один раз в точке входа и передаётся параметрами; зависимости видны и подменяются в тестах.

Глава 5. Реализация на C++23

5.1. Что ограничивает паттерн

Singleton управляет количеством экземпляров и предоставляет к ним точку доступа. В классической форме он ограничивает создание одним экземпляром в определённой области и обычно предоставляет статическую операцию получения ссылки на него.

Перед реализацией нужно определить область единственности. «Один на программу», «один на процесс», «один на контейнер зависимостей» и «один на поток» — разные контракты. Динамические библиотеки, несколько процессов и тестовые окружения могут иметь собственные экземпляры, даже если исходный код одного класса выглядит одинаково.

Одиночка входит в порождающие паттерны GoF. Он полезен, когда ограничение действительно является частью предметной или системной задачи. Само желание обращаться к объекту из любого места не доказывает необходимость Singleton.

5.2. Скрытые зависимости и цена глобального состояния

Глобальная точка доступа может скрыть связь класса с конкретным сервисом. Такой код труднее изолировать в тесте, поменять конфигурацию между сценариями и контролировать порядок завершения. Общий изменяемый объект требует отдельной синхронизации.

Поэтому Singleton нередко считают антипаттерном при безусловном применении. Это критическая оценка последствий, а не утверждение, что каждый единственный объект ошибочен. Альтернатива — создать один обычный сервис в композиционном корне приложения и явно передать его зависимым объектам. В DI-контейнере время жизни Singleton может ограничиваться одним контейнером, а не всем процессом.

5.3. Участники и схема

Класс Singleton обычно закрывает прямое создание, запрещает копирование и перемещение и предоставляет операцию доступа. Клиент получает ссылку или другой оговорённый тип доступа. Если внутри объекта есть изменяемые данные, их защита определяется отдельно.



В C++ локальная статическая переменная функции является основой одиночки Мейерса: при одновременном первом обращении язык синхронизирует её инициализацию. Эта гарантия касается инициализации, а не произвольных последующих методов. В главе логгер дополнительно защищает вывод мьютексом.

5.4. Порядок инициализации и завершения

Динамическая инициализация статических объектов из разных единиц трансляции может зависеть от порядка, который нельзя безопасно предполагать: это называют static initialization order fiasco. Локальная статическая переменная откладывает инициализацию до первого использования, но сама по себе не решает все проблемы порядка разрушения статических объектов.

При завершении приложения нужно гарантировать, что рабочие потоки уже завершены и другие статические деструкторы не обращаются к уничтоженному объекту. Понятный управляемый жизненный цикл часто проще скрытого глобального доступа.

5.5. Классический пример: потокобезопасный Logger

Сначала приведём полную программу. Локальная статическая переменная создаёт Logger при первом вызове; мьютекс защищает записи в поток вывода. std::jthread автоматически присоединяется к рабочему потоку при уничтожении.




Листинг 5.1 — Классический пример: потокобезопасный Logger

Разбор. Logger имеет закрытый конструктор и удалённые операции копирования. При первом вызове instance() создаётся локальная статическая переменная. Одновременные первые вызовы синхронизируются механизмом языка. log() отдельно захватывает мьютекс, чтобы записи разных потоков не перемешивались внутри этого метода.

Вектор jthread уничтожается до проверки результатов, поэтому все три рабочих потока завершены. Каждый поток записывает в отдельный элемент массива адрес полученного логгера; после присоединения главный поток сравнивает адреса. Порядок сообщений работников не гарантирован. До завершения приложения потоки уже остановлены, что уменьшает риск обращения к разрушающемуся статическому объекту.

5.6. Четырнадцать разновидностей и соседних приёмов

1. Classic Lazy Singleton — наивная ленивая реализация

Проверка сырого указателя и new при первом вызове показывает идею отложенного создания, но без синхронизации она небезопасна при нескольких потоках. Нужно также обеспечить освобождение и не сохранять ссылки после него. Работа 2 намеренно ограничена одним потоком и служит разбором недостатков.

2. Eager Initialization Singleton — ранняя инициализация

Экземпляр со статической длительностью хранения подготавливается заранее. Если инициализация динамическая и зависит от других статических объектов, возможны проблемы порядка между единицами трансляции. Работа 3 использует constinit и константную инициализацию простой версии, устраняя именно эту зависимость для примера.

3. Static Block Singleton — инициализация лямбдой

Сразу вызываемая лямбда может подготовить сложное статическое значение и преобразовать ошибку в std::expected. Работа 4 хранит результат инициализации, а клиент проверяет успех. Если ошибка сохранена как значение, этот пример не делает автоматических повторных попыток.

4. Synchronized Accessor Singleton — доступ через мьютекс

Проверка и создание выполняются под мьютексом. Это просто объяснить, но блокировка берётся при каждом получении экземпляра. Методы общего объекта по-прежнему должны отдельно защищать состояние. Работа 5 использует мьютекс для доступа и атомарный счётчик для данных.

5. Double-Checked Locking — двойная проверка

Быстрый путь читает атомарный указатель с acquire; при отсутствии объекта поток захватывает мьютекс и проверяет ещё раз. Создав объект, он публикует указатель с release. Так поток, увидевший указатель через acquire, также видит завершённую инициализацию. Работы 6 и 16 содержат полный пример.

Эта схема сложнее локальной статической переменной и требует корректного управления временем жизни. Особенно опасно обращаться к опубликованному указателю во время разрушения статических объектов.

6. Initialization-on-demand Holder / Meyers' Singleton

Статический локальный объект создаётся при первом обращении. Язык обеспечивает однократную инициализацию при конкурентных вызовах. Это обычно более простой выбор для стандартного ленивого одиночки. Работа 7 показывает менеджер аудиоресурсов; реальные аудиоустройства в ней не открываются.

7. Atomic / CAS Singleton и std::call_once

std::call_once позволяет однократно выполнить успешную инициализацию и повторяет попытку, если функция выбросила исключение. Он может использовать блокировки и не является автоматической гарантией отсутствия взаимных блокировок. Работа 8 использует call_once.

Другой приём — атомарно опубликовать одного победителя через compare-exchange. При этом несколько потоков могут временно построить несколько кандидатов; лишние кандидаты удаляются. Такой подход не подходит, если даже временное дублирование или побочные эффекты конструкторов запрещены. Полный пример CAS приведён ниже; корректность завершения также требует остановить пользователей до очистки.

Полный пример CAS-публикации:



Листинг 5.2 — Четырнадцать разновидностей и соседних приёмов




Листинг 5.2 (продолжение) — Четырнадцать разновидностей и соседних приёмов

Разбор CAS. Каждый поток сначала проверяет атомарный указатель. Если значения нет, он создаёт кандидата в unique_ptr и пытается заменить nullptr своим адресом. Победитель освобождает владение из unique_ptr, а проигравший получает опубликованный адрес в expected и автоматически уничтожает своего кандидата. Cleanup удаляет опубликованный экземпляр при завершении.

Возможность нескольких одновременно созданных кандидатов — существенная особенность примера. Порядок остановки всех потоков до статической очистки является обязательным условием. Атомарность указателя не обещает lock-free реализации на любой платформе и не делает изменяемые методы объекта автоматически безопасными.

8. Enum Singleton / Passkey Tag Singleton

В C++ перечисление не является эквивалентом Java enum с пользовательскими методами и контролем создания. Идиома Passkey решает другую задачу: публичный конструктор требует ключ, который может создать только разрешённый код. Работа 9 показывает Passkey вместе с локальным статическим объектом, отдельно запрещая копирование.

9. Multiton

Вместо единственного объекта создаётся один объект для каждого ключа. Реестр должен синхронизировать одновременные поиск и вставку, иначе два потока могут создать разные объекты для одного ключа. Работа 10 группирует учебные пулы по региону.

10. N-ton / Bounded Singleton

Ограничивается максимальное число выдаваемых объектов. Реализация может выдавать свободный объект, ждать или возвращать ошибку при исчерпании. Работа 11 немедленно возвращает пустую аренду, когда пул модельных декодеров занят. Это не то же самое, что один экземпляр Singleton.

11. Thread-Local Singleton

thread_local создаёт отдельное состояние для каждого потока и уничтожает его при завершении потока. Это уменьшает необходимость синхронизировать именно это состояние, но не означает, что ресурс уникален на весь процесс. Работа 12 показывает независимые генераторы.

12. Subclassed / Polymorphic Singleton

Общая точка доступа может возвращать интерфейс выбранной реализации. В работе 13 первый вызов выбирает настоящую или тестовую файловую систему, а несовместимый повторный выбор отклоняется. Такая глобальная фиксация может мешать независимым тестам; обычное внедрение интерфейса часто гибче.

13. Monostate / Borg

Объектов может быть много, но состояние хранится в статических полях класса. Отсутствие запрета на создание объектов не устраняет глобальное состояние и его последствия. Работа 14 сравнивает Monostate с явной передачей конфигурации.

14. DI-Managed / Ambient Singleton

Обычный класс не содержит глобальной точки доступа; контейнер предоставляет один экземпляр в своей области. Это позволяет создавать независимые контейнеры и подменять зависимость в тестах. Работа 15 демонстрирует такой жизненный цикл на учебном сервисе авторизации.

5.7. Связанные решения

Double-Checked Locking — Singleton + Proxy

Операция доступа сначала проверяет атомарный указатель и обращается к мьютексу только при отсутствии значения. Работы 6 и 16 объясняют публикацию и ограничения завершения. Не заменяйте атомарный указатель обычным: такая двойная проверка создаст гонку данных.

Thread-Specific Storage — Multiton + Proxy

Каждый поток получает собственное состояние через единый интерфейс. Работа 17 использует thread_local и RAII-область для вложенных контекстов транзакций. Это не распределённая транзакция и не общий контекст для пула асинхронных задач, которые могут сменить поток.

Darmowy fragment się skończył.

Ograniczenie wiekowe:
0+
Data wydania na Litres:
18 listopada 2026
Data napisania:
2026
Objętość:
144 str. 157 ilustracji
Właściciel praw:
Автор
Format pobierania: