ефективний потокобезпечний синглтон в C ++

Звичайний шаблон для синглтон-класу - це щось на зразок

static Foo &getInst()
{
  static Foo *inst = NULL;
  if(inst == NULL)
    inst = new Foo(...);
  return *inst;    
}

Однак я розумію, що це рішення не є безпечним для потоку, оскільки 1) конструктор Foo може бути викликаний більше одного разу (що може мати значення, а може і не мати) і 2) inst може бути не повністю побудований до того, як його повернуть в інший потік .

Одне з рішень - обернути мутекс навколо всього методу, але тоді я плачу за накладні витрати на синхронізацію ще довго після того, як мені це насправді потрібно. Альтернатива - це щось на зразок

static Foo &getInst()
{
  static Foo *inst = NULL;
  if(inst == NULL)
  {
    pthread_mutex_lock(&mutex);
    if(inst == NULL)
      inst = new Foo(...);
    pthread_mutex_unlock(&mutex);
  }
  return *inst;    
}

Це правильний спосіб зробити це, чи є якісь підводні камені, про які я повинен знати? Наприклад, чи можуть виникати проблеми із статичним порядком ініціалізації, тобто чи завжди гарантовано inst має значення NULL при першому виклику getInst?

Ваше рішення називається "подвійно перевірене блокування", і те, як ви його написали, не є безпечним.

Ця стаття Мейєрса / Александреску пояснює, чому - але ця папір також широко сприймається неправильно. Він започаткував мем "подвійне перевірене блокування небезпечно в C ++", але його фактичний висновок полягає в тому, що подвійне перевірене блокування в C ++ може бути реалізовано безпечно, для цього просто потрібно використовувати бар'єри пам'яті в неочевидному місці.

Стаття містить псевдокод, який демонструє, як використовувати бар’єри пам’яті для безпечної реалізації DLCP, тому вам не повинно бути важко виправити реалізацію.

Якщо ви використовуєте C ++ 11, ось правильний спосіб зробити це:

Foo& getInst()
{
    static Foo inst(...);
    return inst;
}

Згідно з новим стандартом, більше не потрібно турбуватися про цю проблему. Ініціалізація об’єкта здійснюватиметься лише одним потоком, інші потоки будуть чекати, поки він завершиться. Або ви можете використовувати std :: call_once. (більше інформації тут )

Herb Sutter розповідає про подвійну перевірку блокування в CppCon 2014.

Нижче наведено код, який я реалізував у C ++ 11 на основі цього:

class Foo {
public:
    static Foo* Instance();
private:
    Foo() {}
    static atomic<Foo*> pinstance;
    static mutex m_;
};

atomic<Foo*> Foo::pinstance { nullptr };
std::mutex Foo::m_;

Foo* Foo::Instance() {
  if(pinstance == nullptr) {
    lock_guard<mutex> lock(m_);
    if(pinstance == nullptr) {
        pinstance = new Foo();
    }
  }
  return pinstance;
}

Ви також можете перевірити повну програму тут: http://ideone.com/olvK13

Використання pthread_once, яке гарантує, що функція ініціалізації запускається один раз атомно.

(У Mac OS X він використовує блокування віджимання. Не знаю реалізації інших платформ.)

TTBOMK, єдиним гарантованим потокобезпечним способом зробити це без блокування буде ініціалізація всіх ваших одиночних ліній перед тим, як ви коли-небудь почнете потік.

Ваша альтернатива називається "перевірене блокування" .

Можуть існувати багатопотокові моделі пам'яті, в яких вона працює, але POSIX не гарантує такої

Реалізація ACE в одиночному режимі використовує подвійно перевірений шаблон блокування для безпеки ниток, ви можете звернутися до нього, якщо хочете.

Ви можете знайти вихідний код тут .

Тут працює TLS? https://en.wikipedia.org/wiki/Thread-local_storage#C_and_C++

Наприклад,

static _thread Foo *inst = NULL;
static Foo &getInst()
{
  if(inst == NULL)
    inst = new Foo(...);
  return *inst;    
 }

Але нам також потрібен спосіб його явного видалення, наприклад

static void deleteInst() {
   if (!inst) {
     return;
   }
   delete inst;
   inst = NULL;
}

Рішення не є безпечним для потоку, оскільки оператор

inst = new Foo();

може бути розбитий на два твердження компілятором:

Заява1: inst = malloc (sizeof (Foo));
Заява2: inst-> Foo ();

Припустимо, що після виконання оператора 1 одним потоком відбувається перемикання контексту. І 2-й потік також виконує getInstance()метод. Тоді другий потік виявить, що покажчик 'inst' не є нульовим. Отже, другий потік поверне вказівник на неініціалізований об’єкт, оскільки конструктор ще не викликаний 1-м потоком.