设计模式-创建型模式-单例模式线程安全问题

代码看上一篇文章

饿汉式：对象是在main函数执行前就构造了，因此是线程安全的。缺点是，即是进程中不会调用该对象方法，该对象也会被实例化，这莫名其妙就占用了内存，即是用不上。

懒汉式：对象是在调用时，才被实例化的，在多线程下有可能被实例化成多个对象，因此是非线程安全的。

错误写法：

CLazySingleton *CLazySingleton::instance()
{
    static CLazySingleton * p = NULL;
    if (NULL == p)
    {
        p = new CLazySingleton();
    }

    return p;
}

将静态指针 p初始化为NULL，然后在判断该指针是否为NULL，如果为NULL就创建对象，看着是没什么问题，其实问题大了去。

在多线程环境下，如果在new对象时，系统由于某些原因，实例化对象的速度慢了，而另外一个线程此刻也运行至此处，由于之前的对象为实例化完成，因此指针p此时还是NULL，为此又去实例化一个对象。单例模式实例化了多个对象，gg。

解决方法1：加锁

CLazySingleton *CLazySingleton::instance()
{
    static CLazySingleton * p = NULL;
    g_mutex.lock();
    if (NULL == p)
    {
        p = new CLazySingleton();
    }
    g_mutex.unlock();
    return p;
}

如代码所示，判断指针为空前先加锁，让其他线程执行到此处时挂起，这样可以保证全局只实例化了一个对象。但是也由此引发一个问题，加锁成本是很高的，每次运行至此处都要加一次锁，明明对象已经实例化成功了。

解决方法2：加锁，二次判断

CLazySingleton *CLazySingleton::instance()
{
    static CLazySingleton * p = NULL;
    if (NULL == p)
    {
        g_mutex.lock();
        if (NULL == p)
        {
            p = new CLazySingleton();
        }
        g_mutex.unlock();
    }
    return p;
}

如代码所示，在方法一的基础上加多了一次判断，指针P为空时，加锁再判断一次，此种方法只有第一次实例化对象时才会被加锁，往后再执行到此处不再需要加锁，这就减少了加锁释放锁的成本。

解决方法3：直接构造静态对象

CLazySingleton *CLazySingleton::instance()
{
    static CLazySingleton singleton;
    return &singleton;
}

如代码所示，直接在全局区（静态）构造对象，此方法也能保证对象是单例，但是对象是存储在全局区。

解决方法4：指针存储在全局区，对象在实例化在堆内

CLazySingleton *CLazySingleton::instance()
{
    // 类内创建对象
    // 使用静态对象，保证对象只会被创建一次
    // 此方法已经线程安全
    std::cout << "instance" << std::endl;
    static CLazySingleton * p = new CLazySingleton();
    return p;
}

一般推荐使用此方法。

全代码

#ifndef CLAZYSINGLETON_H
#define CLAZYSINGLETON_H

#include "mutex"

class CLazySingleton
{

private:
    // 构造函数私有，禁止外部创建，释放
    CLazySingleton();
    ~CLazySingleton();
public:
    // 静态方法，全局访问
    static CLazySingleton * instance();
    void say();

private:
    static std::mutex g_mutex;
};

#endif // CLAZYSINGLETON_H

#include "clazysingleton.h"
#include "iostream"

std::mutex CLazySingleton::g_mutex;

CLazySingleton::CLazySingleton()
{
    // 打印字符，观察对象合时被实例化，被实例化多少次？
    std::cout << "constructor" << std::endl;
}

CLazySingleton::~CLazySingleton()
{

}

//CLazySingleton *CLazySingleton::instance()
//{
//    static CLazySingleton singleton;
//    return &singleton;
//}

//CLazySingleton *CLazySingleton::instance()
//{
//    static CLazySingleton * p = NULL;
//    if (NULL == p)
//    {
//        g_mutex.lock();
//        if (NULL == p)
//        {
//            p = new CLazySingleton();
//        }
//        g_mutex.unlock();
//    }
//    return p;
//}

//CLazySingleton *CLazySingleton::instance()
//{
//    static CLazySingleton * p = NULL;
//    g_mutex.lock();
//    if (NULL == p)
//    {
//        p = new CLazySingleton();
//    }
//    g_mutex.unlock();
//    return p;
//}

//CLazySingleton *CLazySingleton::instance()
//{
//    static CLazySingleton * p = NULL;
//    if (NULL == p)
//    {
//        p = new CLazySingleton();
//    }

//    return p;
//}

CLazySingleton *CLazySingleton::instance()
{
    // 类内创建对象
    // 使用静态对象，保证对象只会被创建一次
    // 此方法已经线程安全
    std::cout << "instance" << std::endl;
    static CLazySingleton * p = new CLazySingleton();
    return p;
}

void CLazySingleton::say()
{
    std::cout << "I am LazySingleton!" << std::endl;
}