Question

我上周指的是这样一段代码：

#include <pthread.h>
namespace NSTest
{
class SingletonClass
{
public:


    static SingletonClass & getInstance()
    {
        static  pthread_mutex_t mutex;
        pthread_mutex_lock(&mutex);
        if(singletonPtr==nullptr)
        {
            createInstence();
        }
        return (*singletonPtr);
        pthread_mutex_unlock(&mutex);

    }

private:
    static void createInstence()
    {
        static SingletonClass static_SingletonClass;
        singletonPtr=&static_SingletonClass;

    }
    static SingletonClass * singletonPtr;

};

SingletonClass * SingletonClass::singletonPtr=nullptr;


class SingletonClassNoStatic
{
public:
    static SingletonClassNoStatic & getInstance()
    {
        pthread_mutex_lock(&mutex);
        if(singletonPtr==nullptr)
        {
            createInstence();
        }
        return (*singletonPtr);
        pthread_mutex_unlock(&mutex);
    }
private:
    static void createInstence()
    {
        static SingletonClassNoStatic static_SingletonClass;
        singletonPtr=&static_SingletonClass;

    }
    static SingletonClassNoStatic * singletonPtr;

    static  pthread_mutex_t mutex;
};
SingletonClassNoStatic * SingletonClassNoStatic::singletonPtr=nullptr;
pthread_mutex_t SingletonClassNoStatic::mutex;
}
int main()
{

    NSTest::SingletonClass::getInstance();
    NSTest::SingletonClassNoStatic::getInstance();

    return 0;
}

方法getInstance，被指向是正确的，原始的是getIntance（StaticMutex），编码不是线程安全的（c ++ 98），因为互斥体是在方法中创建的，它是静态的，使用静态互斥锁，我遵循静态方法的规则创建一次并且不再创建静态方法，但此规则自不应用于互斥锁。我怀疑，纠正可以吗？访问该方法的每个线程（静态互斥锁）都将创建自己的互斥锁？我在读这个动作只是方法是来自类的方法，但是因为互斥体在静态方法中是静态创建的，所以它将被创建一次。我是否正确理解了这个概念？

Answer 1

在C ++ 11中（由std :: mutex暗示）整个Meyers单例表示为两行：

Singleton& instance() {
  static Singleton instance;

  return instance;
}

不需要其他任何东西。问题本身非常不清楚，因为你在相同的上下文中谈论C ++ 98和std :: mutex，而那些不加起来。

发布代码的另一个问题是它开始时是不迈耶的单身人士。

C ++ Meyers Singleton - 线程安全（代码相当于互斥？）

1 个答案: