71

现在 C++11 具有多线程，我想知道在不使用互斥锁的情况下实现延迟初始化单例的正确方法是什么（出于性能原因）。我想出了这个，但是我不太擅长编写无锁代码，所以我正在寻找一些更好的解决方案。

// ConsoleApplication1.cpp : Defines the entry point for the console application.
//
# include <atomic>
# include <thread>
# include <string>
# include <iostream>
using namespace std;
class Singleton
{

public:
    Singleton()
    {
    }
static  bool isInitialized()
    {
        return (flag==2);
    }
static  bool initizalize(const string& name_)
    {
        if (flag==2)
            return false;// already initialized
        if (flag==1)
            return false;//somebody else is initializing
        if (flag==0)
        {
            int exp=0;
            int desr=1;
            //bool atomic_compare_exchange_strong(std::atomic<T>* obj, T* exp, T desr)
            bool willInitialize=std::atomic_compare_exchange_strong(&flag, &exp, desr);
            if (! willInitialize)
            {
                //some other thread CASed before us
                std::cout<<"somebody else CASed at aprox same time"<< endl;
                return false;
            }
            else 
            {
                initialize_impl(name_);
                assert(flag==1);
                flag=2;
                return true;
            }
        }
    }
static void clear()
{
    name.clear();
    flag=0;
}
private:
static  void initialize_impl(const string& name_)
{
        name=name_;
}
static  atomic<int> flag;
static  string name;
};
atomic<int> Singleton::flag=0;
string Singleton::name;
void myThreadFunction()
{
    Singleton s;
    bool initializedByMe =s.initizalize("1701");
    if (initializedByMe)
        s.clear();

}
int main()
{
    while (true)
    {
        std::thread t1(myThreadFunction);
        std::thread t2(myThreadFunction);
        t1.join();
        t2.join();
    }
    return 0;
}

请注意，这clear()只是为了测试，真正的单身人士不会有这个功能。

4

6 回答 6

162

C++11 消除了手动锁定的需要。如果静态局部变量已经被初始化，并发执行将等待。

§6.7 [stmt.dcl] p4

如果在变量初始化时控制同时进入声明，则并发执行将等待初始化完成。

因此，简单的static函数如下：

static Singleton& get() {
  static Singleton instance;
  return instance;
}

这在 C++11 中可以正常工作（当然，只要编译器正确实现了标准的那部分）。

当然，真正正确的答案是不使用单例句号。

于 2012-07-29T18:52:21.700 回答
46

使用 C++11 实现单例的最简单方法可能是：

警告：虽然这根据 C++11 标准工作（静态初始化程序是线程安全的），但这在 Microsoft Visual C++ 2012 中没有正确实现（静态初始化程序不是线程安全的）。如果您的目标是 VC2012，那么您必须使用不同的方法，因为它没有完全实现 C++11 标准。

class Singleton {
 public:
  static Singleton& Instance() {
    // Since it's a static variable, if the class has already been created,
    // it won't be created again.
    // And it **is** thread-safe in C++11.
    static Singleton myInstance;

    // Return a reference to our instance.
    return myInstance;
  }

  // delete copy and move constructors and assign operators
  Singleton(Singleton const&) = delete;             // Copy construct
  Singleton(Singleton&&) = delete;                  // Move construct
  Singleton& operator=(Singleton const&) = delete;  // Copy assign
  Singleton& operator=(Singleton &&) = delete;      // Move assign

  // Any other public methods.

 protected:
  Singleton() {
    // Constructor code goes here.
  }

  ~Singleton() {
    // Destructor code goes here.
  }

 // And any other protected methods.
}
于 2016-01-07T11:03:09.517 回答
5

恕我直言，实现单例的最佳方法是使用“双重检查，单锁”模式，您可以在 C++ 11 中可移植地实现该模式： 在 C++11 中修复了双重检查锁定 这种模式已经很快 - created case，只需要一个指针比较，并且在第一个用例中是安全的。

如上一个答案所述，C++ 11 保证静态局部变量的构造顺序安全 C++11 中的局部静态变量初始化线程安全吗？所以你可以安全地使用该模式。但是，Visual Studio 2013 还不支持它 :-(请参阅此页面上的“magic statics”行，因此如果您使用的是 VS2013，您仍然需要自己做。

不幸的是，没有什么是简单的。上述模式引用的示例代码不能从 CRT 初始化中调用，因为静态 std::mutex 有一个构造函数，因此不能保证在第一次调用获取单例之前被初始化，如果所述调用是一个侧面- CRT 初始化的影响。为了解决这个问题，您必须使用，而不是互斥锁，而是指向互斥锁的指针，保证在 CRT 初始化开始之前将其初始化为零。然后你必须使用 std::atomic::compare_exchange_strong 来创建和使用互斥锁。

我假设即使在 CRT 初始化期间调用 C++ 11 线程安全的本地静态初始化语义也可以工作。

因此，如果您有可用的 C++ 11 线程安全本地静态初始化语义，请使用它们。如果没有，您还有一些工作要做，更何况如果您希望您的单例在 CRT 初始化期间是线程安全的。

于 2015-01-20T16:21:43.123 回答
4 
template<class T> 
class Resource
{
    Resource<T>(const Resource<T>&) = delete;
    Resource<T>& operator=(const Resource<T>&) = delete;
    static unique_ptr<Resource<T>> m_ins;
    static once_flag m_once;
    Resource<T>() = default;

public : 
    virtual ~Resource<T>() = default;
    static Resource<T>& getInstance() {
        std::call_once(m_once, []() {
            m_ins.reset(new Resource<T>);
        });
        return *m_ins.get();
    }
};
于 2018-05-15T09:11:09.620 回答
2

很难阅读您的方法，因为您没有按预期使用代码......也就是说，单例的常见模式是调用instance()以获取单个实例，然后使用它（另外，如果您真的想要一个单例，不构造函数应该是公共的）。

无论如何，我不认为你的方法是安全的，考虑到两个线程试图获取单例，第一个更新标志的线程将是唯一一个正在初始化的线程，但该initialize函数将在第二个线程提前退出一个，并且该线程可能会在第一个线程完成初始化之前继续使用单例。

你的语义initialize被破坏了。如果您尝试描述/记录函数的行为，您会获得一些乐趣，并且最终会描述实现而不是简单的操作。记录文档通常是仔细检查设计/算法的一种简单方法：如果您最终描述的是如何 而不是描述了什么，那么您应该回到设计。特别是，不能保证在initialize完成后对象实际上已被初始化（仅当返回值为true时，有时如果是false，但并非总是如此）。

于 2012-07-29T20:07:13.727 回答
2 
#pragma once

#include <memory>
#include <mutex>

namespace utils
{

template<typename T>
class Singleton
{
private:
    Singleton<T>(const Singleton<T>&) = delete;
    Singleton<T>& operator = (const Singleton<T>&) = delete;

    Singleton<T>() = default;

    static std::unique_ptr<T> m_instance;
    static std::once_flag m_once;

public:
    virtual ~Singleton<T>() = default;

    static T* getInstance()
    {
        std::call_once(m_once, []() {
            m_instance.reset(new T);
        });
        return m_instance.get();
    }

    template<typename... Args>
    static T* getInstance2nd(Args&& ...args)
    {
        std::call_once(m_once, [&]() {
            m_instance.reset(new T(std::forward<Args>(args)...));
        });
        return m_instance.get();
    }
};

template<typename T> std::unique_ptr<T> Singleton<T>::m_instance;
template<typename T> std::once_flag Singleton<T>::m_once;

}

此版本符合并发免费，但不能保证 100% 支持 c++11 标准。它还提供了一种灵活的方式来实例化“拥有”实例。即使神奇的静态词在 c++11 和更高版本中已经足够，开发人员也可能需要对实例创建进行更多控制。

于 2019-03-22T09:46:45.090 回答