『设计模式』单例模式

Hfjsbdhc

已于 2023-08-23 11:28:04 修改

阅读量79

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签：设计模式单例模式 c++

于 2023-08-22 16:58:16 首次发布

本文链接：https://blog.csdn.net/HAICHANG1105/article/details/132431612

设计模式专栏收录该内容

3 篇文章

订阅专栏

文章讨论了三种线程安全的单例模式实现方法：原始的懒汉模式、使用原子变量改进的懒汉模式以及局部静态变量版本。主要关注了如何在多线程环境下确保任务队列的实例只被创建一次。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include <iostream>
#include <mutex>
using namespace std;

#if 0
//饿汉模式
class TaskQueue
{
public:
    TaskQueue(const TaskQueue &t) = delete;
    TaskQueue& operator=(const TaskQueue &t) = delete;

    static TaskQueue* getInstance()
    {
        return m_tQueue;
    }

    void print()
    {
        cout << "task queue......." << endl;
    }
private:
    TaskQueue() = default;

    static TaskQueue *m_tQueue;
};
TaskQueue* TaskQueue::m_tQueue = new TaskQueue;

#else
// 懒汉模式
class TaskQueue
{
public:
    TaskQueue(const TaskQueue &t) = delete;
    TaskQueue &operator=(const TaskQueue &t) = delete;

    static TaskQueue *getInstance()
    {
        if (m_tQueue == nullptr) //双重检查锁定，可以多线程同时并行获取实例
        {
            m_mutex.lock();  //加互斥锁，可以防止多线程访问时，创建多个实例
            if (m_tQueue == nullptr)
            {
                m_tQueue = new TaskQueue;
            }
            m_mutex.unlock();
            
        }
        

        return m_tQueue;
    }

    void print()
    {
        cout << "task queue success create." << endl;
    }

private:
    TaskQueue() = default;

    static TaskQueue *m_tQueue;
    static mutex m_mutex;
};

TaskQueue *TaskQueue::m_tQueue = nullptr;
mutex TaskQueue::m_mutex;
#endif

int main(int argc, const char **argv)
{

    TaskQueue *task = TaskQueue::getInstance();
    task->print();
    return 0;
}

使用原子变量解决双重检查锁定的问题

#include <iostream>
#include <mutex>
#include <atomic>
using namespace std;

// 懒汉模式
class TaskQueue
{
public:
    TaskQueue(const TaskQueue &t) = delete;
    TaskQueue &operator=(const TaskQueue &t) = delete;

    static TaskQueue *getInstance()
    {
        TaskQueue *task = m_ato_tQueue.load();
        if ( task == nullptr) 
        {
            m_mutex.lock(); 
            task = m_ato_tQueue.load(); //是为了多线程时，获取到锁的线程从原子里取出数据，然后再判断
            if (task == nullptr)
            {
                task = new TaskQueue;
                m_ato_tQueue.store(task);
            }
            m_mutex.unlock();
        }

        return task;
    }

    void print()
    {
        cout << "task queue success create." << endl;
    }

private:
    TaskQueue() = default;

    // static TaskQueue *m_tQueue;
    static atomic<TaskQueue*> m_ato_tQueue;
    static mutex m_mutex;
};

atomic<TaskQueue*> TaskQueue::m_ato_tQueue;
mutex TaskQueue::m_mutex;

int main(int argc, const char **argv)
{

    TaskQueue *task = TaskQueue::getInstance();
    task->print();
    return 0;
}

局部静态变量解决线程安全问题

#include <iostream>
#include <mutex>
#include <atomic>
using namespace std;

// 懒汉模式
class TaskQueue
{
public:
    TaskQueue(const TaskQueue &t) = delete;
    TaskQueue &operator=(const TaskQueue &t) = delete;

    static TaskQueue *getInstance()
    {
        
        static TaskQueue tQueue; //局部取出变量
        return &tQueue;
    }

    void print()
    {
        cout << "task queue create successfully." << endl;
    }

private:
    TaskQueue() = default;

   
};


int main(int argc, const char **argv)
{

    TaskQueue *task = TaskQueue::getInstance();
    task->print();
    return 0;
}