Является ли следующая реализация, использующая ленивую инициализацию, безопасным потоком Singleton (Meyers 'Singleton)?
static Singleton& instance()
{
static Singleton s;
return s;
}
Если нет, почему и как сделать его потокобезопасным?
В C++11 он является потокобезопасным. В соответствии со стандартом §6.7 [stmt.dcl] p4:
Если элемент управления входит в объявление одновременно, когда переменная инициализируется, параллельное выполнение должно ждать для завершения инициализации.
Поддержка GCC и VS для функции (Динамическая инициализация и уничтожение с помощью Concurrency, также известная как Magic Statics на MSDN) выглядит следующим образом:
Спасибо @Mankarse и @olen_gam за их комментарии.
В C++03 этот код не был потокобезопасным. Существует статья Мейерса, называемая "С++ и опасностями блокировки с двойной проверкой" , в которой обсуждаются поточно-безопасные реализации шаблона, и вывод, более или менее, что (в С++ 03) полная блокировка вокруг метода создания является в основном простейшим способом обеспечения правильного concurrency на всех платформах, в то время как большинство форм двойных проверок вариантов шаблонов могут пострадать от условия гонки на определенных архитектурах, если только команды не чередуются с стратегически мерами памяти.
Чтобы ответить на вопрос о том, почему он не является потоковым, это не потому, что первый вызов instance() должен вызвать конструктор для Singleton s. Чтобы быть потокобезопасными, это должно было произойти в критическом разделе, но в стандарте нет требования о том, чтобы критический раздел был принят (стандарт на сегодняшний день полностью отключен для потоков). Компиляторы часто реализуют это, используя простую проверку и приращение статического булева, но не в критическом разделе. Что-то вроде следующего псевдокода:
static Singleton& instance()
{
static bool initialized = false;
static char s[sizeof( Singleton)];
if (!initialized) {
initialized = true;
new( &s) Singleton(); // call placement new on s to construct it
}
return (*(reinterpret_cast<Singleton*>( &s)));
}
Итак, вот простой потокобезопасный Singleton (для Windows). Он использует простую оболочку класса для объекта Windows CRITICAL_SECTION, так что мы можем заставить компилятор автоматически инициализировать CRITICAL_SECTION до вызова main(). В идеале должен использоваться истинный класс RAII критического сечения, который может иметь дело с исключениями, которые могут возникнуть при сохранении критического раздела, но выходящими за рамки этого ответа.
Основная операция заключается в том, что, когда запрашивается экземпляр Singleton, выполняется блокировка, Singleton создается, если это необходимо, затем блокировка освобождается и возвращается ссылка Singleton.
#include <windows.h>
class CritSection : public CRITICAL_SECTION
{
public:
CritSection() {
InitializeCriticalSection( this);
}
~CritSection() {
DeleteCriticalSection( this);
}
private:
// disable copy and assignment of CritSection
CritSection( CritSection const&);
CritSection& operator=( CritSection const&);
};
class Singleton
{
public:
static Singleton& instance();
private:
// don't allow public construct/destruct
Singleton();
~Singleton();
// disable copy & assignment
Singleton( Singleton const&);
Singleton& operator=( Singleton const&);
static CritSection instance_lock;
};
CritSection Singleton::instance_lock; // definition for Singleton lock
// it initialized before main() is called
Singleton::Singleton()
{
}
Singleton& Singleton::instance()
{
// check to see if we need to create the Singleton
EnterCriticalSection( &instance_lock);
static Singleton s;
LeaveCriticalSection( &instance_lock);
return s;
}
Человек - это много дерьма, чтобы "сделать лучшее глобальное".
Основные недостатки этой реализации (если я не пропустил некоторые ошибки):
new Singleton() выбрасывает, блокировка не будет выпущена. Это можно исправить, используя истинный объект блокировки RAII, а не простой, который у меня есть. Это также может помочь сделать вещи переносимыми, если вы используете что-то вроде Boost для обеспечения независимой от платформы оболочки для блокировки.main() - если вы вызываете его до этого (например, при инициализации статического объекта), все может не работать, потому что CRITICAL_SECTION может не быть инициализирован.Глядя на следующий стандарт (раздел 6.7.4), он объясняет, насколько статическая локальная инициализация является потокобезопасной. Поэтому, когда этот раздел стандарта будет широко реализован, Meyer Singleton станет предпочтительной реализацией.
Я уже не согласен со многими ответами. Большинство компиляторов уже реализуют статическую инициализацию таким образом. Одним из примечательных исключений является Microsoft Visual Studio.
Правильный ответ зависит от вашего компилятора. Он может решить сделать это потокобезопасным; это не "naturallly" threadsafe.
Является ли следующая реализация [...] потоком безопасной?
На большинстве платформ это не является потокобезопасным. (Приложите обычный отказ от ответственности, объяснив, что стандарт С++ не знает о потоках, поэтому на законных основаниях он не говорит, является это или нет.)
Если нет, то почему [...]?
Причина не в том, что ничто не мешает нескольким потокам одновременно выполнять конструктор s '.
как сделать его потокобезопасным?
"С++ и опасения блокировки с двойным проверением" Скотта Мейерса и Андрея Александреску - довольно хороший трактат по теме нити - безопасные синглтоны.
Как сказал MSalters: это зависит от используемой вами реализации на С++. Проверьте документацию. Что касается другого вопроса: "Если нет, то почему?" - Стандарт С++ ничего не говорит о потоках. Но предстоящая версия С++ знает потоки, и она явно заявляет, что инициализация статических локальных сетей является потокобезопасной. Если два потока вызывают такую функцию, один поток выполняет инициализацию, а другой будет блокировать и ждать завершения.