C++ 为什么是迈耶'；s的单例方法不是线程安全的？

我从许多讨论中了解到Meyers Singleton提供了线程安全性。为了了解这一点，我在C++14中编写了如下的简单代码

#include <iostream>
#include <thread>

class SingletonClass {
 public:
       static SingletonClass& Instance() {
           static SingletonClass instance;
           return instance;
       }
       
       void task1() {
           for (int i = 0; i < 50000; ++i)
               a++;
       }
       int getA() {return a;}

   private:
       SingletonClass()= default;
       ~SingletonClass()= default;
       SingletonClass(const SingletonClass&)= delete;
       SingletonClass& operator=(const SingletonClass&)= delete;

       int a;
};

void callSingleton() {
   SingletonClass::Instance().task1();
}

int main() {
   std::thread t1(callSingleton);
   std::thread t2(callSingleton);
   
   t1.join();
   t2.join();

   std::cout << "a: " << SingletonClass::Instance().getA() << std::endl;

   return 0;
}

#包括
#包括
类单音类{
公众：
静态SingletonClass&Instance（）{
静态单例类实例；
返回实例；
}
void task1（）{
对于（int i=0；i<50000；++i）
a++；
}
int getA（）{返回a；}
私人：
SingletonClass（）=默认值；
~SingletonClass（）=默认值；
SingletonClass（const SingletonClass&）=delete；
SingletonClass&运算符=（const SingletonClass&）=删除；
INTA；
};
void callSingleton（）{
SingletonClass:：Instance（）.task1（）；
}
int main（）{
std：：线程t1（callSingleton）；
std：：线程t2（callSingleton）；
t1.join（）；
t2.连接（）；
std:：cout因为
a
中的数据竞争

void task1() {
    for (int i = 0; i < 50000; ++i){
        std::lock_guard<std::mutex> lock(mLock);
        a++;
    }
}

void task1（）{
对于（int i=0；i<50000；++i）{
标准：锁和防护锁（mLock）；
a++；
}
}

或定义

atomic<int> a;

原子a；

因为
a
中的数据竞争，我得到了100000英镑

void task1() {
    for (int i = 0; i < 50000; ++i){
        std::lock_guard<std::mutex> lock(mLock);
        a++;
    }
}

void task1（）{
对于（int i=0；i<50000；++i）{
标准：锁和防护锁（mLock）；
a++；
}
}

或定义

atomic<int> a;

原子a；

对于这两个，我都得到100000。
您的Meyers singleton访问是线程安全的。线程不能违反它是一个singleton。但是，检索到的对象不会自动成为线程安全的。您的Meyers singleton访问是线程安全的。线程不能违反它是一个singleton。但是，检索到的对象不会自动成为thread-safe。感谢您的回复。我同意这些解决方案，我也尝试了它们，得到了100000。然而，让我困惑的是，如果我不能像那样使用这个单例类，我如何使用它的线程安全功能。从线程安全，我理解多个线程不应该同时修改数据，但在这里我无法获得Meyers的螺纹安全点Singleton@finesttea据我所知，该类已删除了复制构造函数和复制赋值，以及私有构造函数。
静态SingletonClass实例
确保只创建并立即返回一个对象。如果第一个线程创建了该对象，则第二个线程只会返回它而不创建一个新的。线程安全是指访问对象，而不是类中的成员。谢谢你的回答。我同意这些解决方案，我也尝试了它们，得到了100000。但是，让我困惑的是，如果我不能像那样使用这个单例类，我如何使用它的线程安全功能。从线程-安全，我理解多个线程不应该同时修改数据，但在这里我无法理解Meyers的线程安全性Singleton@finesttea据我所知，该类已经删除了复制构造函数和复制赋值，并且删除了私有构造函数。
静态SingletonClass实例
确保仅在创建并立即返回e对象。如果第一个线程创建了对象，第二个线程将只返回它而不创建新的对象。线程安全在于访问对象，而不是类中的成员。