C++线程安全的单例模式

实现C++线程安全的案例模式的三种方式：

• 局部静态变量
• 饿汉式初始化
• 懒汉式初始化

局部静态变量（最常见）

我们知道在一个函数中定义一个静态局部变量，它只会初始化一次，就是在这个函数第一次调用的时候，以后无论调用几次，函数内的局部变量都不再初始化，并且所有对象的静态成员变量都共享同一块静态存储空间。

#include <iostream>
using namespace std;
//C++11以前该方式存在风险，在多个线程初始化时可能会开辟多个实例
//C++11之后，编译器经过优化了，不会在出现多个实例的问题，也是最简单的一种方式。
class Single {
private:
    Single() {

    }
    Single(const Single&) = delete;     //禁止拷贝构造
    Single& operator=(const Single&) = delete;     //禁止拷贝复制
public:
    static Single& GetInst() {
        static Single single;
        return single;
    }
};
void test_single() {
    //多线程下可能出现问题
    cout << "s1 address is" << &Single::GetInst() << endl;
    cout << "s2 address is" << &Single::GetInst() << endl;
}
int main()
{
    test_single();
    return 0;
}

 

当然在C++11之前，其他人为了避免简单的静态局部变量实现单例模式带来的弊端

设计出了饿汉式初始化，和懒汉式初始化

饿汉式初始化

主线程启动之后，在其他线程没有启动之前，由主线程立马先初始化单例资源，这样其他线程就无法重复初始化了。

#include <iostream>
#include <thread>
using namespace std;
class SingleHungry {
private:
    SingleHungry() {            //无参构造 

    }
    SingleHungry(const SingleHungry&) = delete;     //禁止拷贝构造 
    SingleHungry& operator=(const SingleHungry&) = delete;     //禁止拷贝复制 
public:
    static SingleHungry* GetInst() {
        if (single == nullptr) {
            single = new SingleHungry();
        }
        return single;
    }
private:
    static SingleHungry* single;
};
//饿汉式初始化
SingleHungry* SingleHungry::single = SingleHungry::GetInst();
static int index = 0;
void thread_fun() {
    cout << "this is thread：" << index++ << endl;
    cout << "address is：" << SingleHungry::GetInst() << endl;
}
void test_singlehungry() {
    cout << "s1 address is：" << SingleHungry::GetInst() << endl;    //主线程
    cout << "s2 address is：" << SingleHungry::GetInst() << endl;    //主线程
    for (int i = 0; i < 3; i++)        //3个子线程
    {
        std::thread tid(thread_fun);
        tid.join();
    }
}
int main()
{
    test_singlehungry();
    return 0;
}

 

懒汉式初始化

很多人觉得什么时候调用是用户的权力，不应该加以限制，所以就有了懒汉式方式初始化资源，在用到的时候如果没有初始化单例则初始化，如果初始化了则直接使用。

所以这种方式我们要加锁，防止资源被重复初始化。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
//如果用农户使用懒汉式就需要加锁
//但是回收指针同样存在问题，存在多重释放或者不知道哪个指针释放的问题。
class SingleLazy {
private:
    SingleLazy() {            //无参构造 

    }
    SingleLazy(const SingleLazy&) = delete;     //禁止拷贝构造 
    SingleLazy& operator=(const SingleLazy&) = delete;     //禁止拷贝复制 
public:
    static SingleLazy* GetInst() {
        if (single != nullptr) 
        {
            return single;    //已被初始化，直接返回
        }
        s_mutex.lock();
        if (single != nullptr) 
        {
            s_mutex.unlock();
            return single;
        }
        single = new SingleLazy();        //无法确定如何回收
        s_mutex.unlock();
        return single;
    }
private:
    static SingleLazy* single;
    static std::mutex s_mutex;
};
//饿汉式初始化
SingleLazy* SingleLazy::single = nullptr;
std::mutex SingleLazy::s_mutex;

void thread_fun(int i) {
    cout << "this is lazy thread：" << i << endl;
    cout << "address is：" << SingleLazy::GetInst() << endl;
}
void test_singlelazy() {
    for (int i = 0; i < 3; i++)        //3个子线程
    {
        std::thread tid(thread_fun,i);
        tid.join();
    }
    //合适释放new的对象？造成内存泄漏。
}
int main()
{
    test_singlelazy();
    return 0;
}

 但是new出来的对象，什么时候释放呢？

 

可以利用智能指针完成自动回收。

#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
//如果用户使用懒汉式就需要加锁
//但是回收指针同样存在问题，存在多重释放或者不知道哪个指针释放的问题。
class SingleAuto {
private:
    SingleAuto() //无参构造 
    {            

    }
    SingleAuto(const SingleAuto&) = delete;     //禁止拷贝构造 
    SingleAuto& operator=(const SingleAuto&) = delete;     //禁止拷贝复制 
public:
    ~SingleAuto() 
    {
        cout << "Single auto delete success" << endl;
    }
    static std::shared_ptr<SingleAuto> GetInst() {
        if (single != nullptr) 
        {
            return single;    //已被初始化，直接返回
        }
        s_mutex.lock();
        if (single != nullptr) 
        {
            s_mutex.unlock();
            return single;
        }
        single = std::shared_ptr<SingleAuto>(new SingleAuto);    //智能指针，自动回收内存
        s_mutex.unlock();
        return single;
    }
private:
    static std::shared_ptr<SingleAuto> single;
    static std::mutex s_mutex;
};
//饿汉式初始化
std::shared_ptr<SingleAuto> SingleAuto::single = nullptr;
std::mutex SingleAuto::s_mutex;

void thread_singleauto(int i) {
    cout << "this is auto thread：" << i << endl;
    cout << "address is：" << SingleAuto::GetInst() << endl;
}
void test_singleauto() {
    for (int i = 0; i < 3; i++)        //3个子线程
    {
        std::thread tid(thread_singleauto,i);
        tid.join();
    }
}
int main()
{
    test_singleauto();
    return 0;
}