单例模式详解

最新推荐文章于 2025-03-16 17:08:38 发布
最新推荐文章于 2025-03-16 17:08:38 发布
阅读量1.7k 收藏 4
点赞数 3
文章标签： 实例 对象 结构 软件设计 解决方案
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/snow_5288/article/details/76306226
版权
本文详细介绍了单例模式的定义、动机、实现要点、优缺点以及分类。重点讲解了懒汉模式和饿汉模式的多种实现方式，包括线程安全、避免死锁、内存栅栏等优化手段，以及在不同场景下的适用性和资源管理策略。

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

一、什么是单例模式

1、定义
官方定义是这样的，单例模式是一种常用的软件设计模式，也叫单件模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。通俗点来说，就是一个类只允许实例化一个对象。

2、动机
对于系统中的某些类来说，只有一个实例很重要，例如，一个系统中可以存在多个打印任务，但是只能有一个正在工作的任务;一个系统只能有一个窗口管理器或文件系统;一个系统只能有一个计时工具或ID(序号)生成器。如在Windows中就只能打开一个任务管理器。如果不使用机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源;如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，与实际不符，也会给用户带来误解，不知道哪一个才是真实的状态。因此有时确保系统中某个对象的唯一性即一个类只能有一个实例非常重要。

如何保证一个类只有一个实例并且这个实例易于被访问呢?定义一个全局变量可以确保对象随时都可以被访问，但不能防止我们实例化多个对象。一个更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的模式动机。

3、实现要点：
1>单例类保证全局只有唯一一个自行创建的实例对象。
2.>单例类提供获取这个唯一实例的接口。

4、优缺点
优点：
1>实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本，从而确保所有对象都访问唯一实例。

2>灵活性
因为类控制了实例化过程，所以类可以灵活更改实例化过程。

缺点
1>开销
虽然数量很少，但如果每次对象请求引用时都要检查是否存在类的实例，将仍然需要一些开销。可以通过使用静态初始化解决此问题。

2>可能的开发混淆
使用单例对象(尤其在类库中定义的对象)时，开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码，因此应用程序开发人员可能会意外发现自己无法直接实例化此类。

3>对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中(例如基于.NET Framework的语言)，只有单例类能够导致实例被取消分配，因为它包含对该实例的私有引用。在某些语言中(如 C++)，其他类可以删除对象实例，但这样会导致单例类中出现悬浮引用。

5、分类
单例的分类：懒汉模式（lazy load）、饿汉模式。
懒汉模式:只有当调用对象是才创建对象–相对而言，复杂—-但适用性高，各种场景下都适用。
饿汉模式：在函数一开始就创建（main）–简单高效，但是在某些场景下有缺陷—-适用性会受到限制，动态库。

二、懒汉模式的模拟实现（灰常重要）

实现方式一：普通写法

class Singleton
{
public:
    static Singleton* GetInstance()//获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }
        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" << _a << endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
        :_a(0)
    {}

    int _a;
    static Singleton* _inst;//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
};

Singleton* Singleton::_inst = NULL;//给静态成员指针初始化

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
}

运行结果：
这里写图片描述

由打印结果可知，我们设计的类确实只实例化出了一个对象，观察代码，我们发现虽然构造函数已经设置为私有的了，不能创建新的对象，但是我们仍然可以调用该类的拷贝构造函数和赋值运算符重载来创建其他对象，说到此处，我们就不得不对拷贝构造和赋值运算符重载也进行设定。

改进：类似实现一个防拷贝的类

class Singleton
{
public:
    static Singleton* GetInstance()//获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }
        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;//指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
};

Singleton* Singleton::_inst = NULL;//给静态成员指针初始化

实现方式二：考虑线程安全的写法
上述实现代码虽然大体功能已经符合要求，但是考虑细节问题时，它还是有很多纰漏的。诸如：在获取对象时的判断语句NULL == _inst， 如果内存中有两个线程同时在执行这句代码，在看到_inst时，他们都认为指针为空，于是同时进入if语句创建实例，从而违背单例模式的要求。

#include<iostream>
using namespace std;

#include<mutex>
class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        _mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }
        _mtx.unlock();//解锁

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
}

运行结果：
这里写图片描述

Bug:上述加锁行为确实解决了线程安全问题，但是同时却引入了另一个麻烦，当一个线程进入到if语句创建实例时，可能由于栈空间不够或者某种异常中断导致程序异常终止，但是加的锁并没有进行解锁操作，导致其他线程也无法创建单例对象，从而导致死锁。

实现方式三：利用RAII机制自己“造轮子”避免死锁
RAII：资源获取即初始化，相当于资源分配和初始化时原子操作，其中不会中断

#include<iostream>
using namespace std;

#include<mutex>
class Lock
{
public:
    Lock(mutex& mtx)
        :_mtx(mtx)
    {
        _mtx.lock();
    }
    ~Lock()
    {
        _mtx.unlock();
    }
private:
    Lock(const Lock&);//防止拷贝
    Lock& operator=(const Lock&);//防止赋值

    mutex& _mtx;
};
class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
        Lock lock(_mtx);//RAII机制

        if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
        {
            _inst = new Singleton;
        }

        //_mtx.unlock();//解锁

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化
void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
}

运行结果：
这里写图片描述

上述代码确实避免了死锁问题，但是有一点不足，那就是不够高效。
改进一：添加双检查机制

#include<mutex>
class Lock
{
public:
    Lock(mutex& mtx)
        :_mtx(mtx)
    {
        _mtx.lock();
    }
    ~Lock()
    {
        _mtx.unlock();
    }
private:
    Lock(const Lock&);//防止拷贝
    Lock& operator=(const Lock&);//防止赋值

    mutex& _mtx;
};
class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率
        {
            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
            Lock lock(_mtx);//RAII机制

            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
            {
                _inst = new Singleton;
            }

            //_mtx.unlock();//解锁
        }

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

改进二：调用库里的函数来避免自己造轮子的开销

class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率
        {
            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
            //Lock lock(_mtx);//RAII机制
            lock_guard<mutex>lock(_mtx);

            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
            {
                _inst = new Singleton;
            }

            //_mtx.unlock();//解锁
        }

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

实现方式四：巧用内存栅栏系统函数再次优化
特点：内存栅栏之前的语句和内存栅栏之后的语句不能交换执行次序。

运行程序，在以下代码处下断点：

if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
{
    _inst = new Singleton;
}

查看汇编指令：
这里写图片描述

由图可知，_inst = new Singleton;语句底层是由多条汇编代码来完成执行的，当然也就不是原子操作了，那么各条汇编指令的执行顺序我们也就无从得知了，在目前还算比较智能的编译器中很有可能为了追求效率二而打乱它们的执行顺序，从而可能触发错误。如:

如：原本顺序：operator new开空间–>构造函数–>赋值
如果顺序打乱为:operator new开空间–>赋值–>构造函数
此种情况下引入的双检查机制就会导致对没有初始化的变量进行赋值，使用未初始化的很有可能导致程序崩溃，当然也有可能影响并不大，为了完美起见，我们还是对其进行处理。

#include<iostream>
using namespace std;

#include<mutex>
#include<windows.h>
//class Lock
//{
//public:
//  Lock(mutex& mtx)
//      :_mtx(mtx)
//  {
//      _mtx.lock();
//  }
//  ~Lock()
//  {
//      _mtx.unlock();
//  }
//private:
//  Lock(const Lock&);//防止拷贝
//  Lock& operator=(const Lock&);//防止赋值
//
//  mutex& _mtx;
//};

class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率
        {
            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
            //Lock lock(_mtx);//RAII机制
            lock_guard<mutex>lock(_mtx);

            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
            {
                //_inst = new Singleton;
                Singleton* tmp = new Singleton;
                MemoryBarrier();//优化----内存栅栏，防止编译器对指令流水进行乱序优化
                _inst = tmp;
            }

            //_mtx.unlock();//解锁
        }

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
}

运行结果：
这里写图片描述

实现方式五：实例销毁处理
代码写到这里，基本已经差不多了，但是有人会想既然实例是new出来的，那么我们为什么不用delete将其释放掉呢，难道不会内存泄漏么？结果是当然会的，为什么不析构单例的实例呢，是因为它本身是一个静态的全局实例，之所以只能定义唯一一个，肯定是用的次数比较多，如果刚释放完空间又来创建单例对象，肯定就不得不偿失了。反过来说，单例模式一共就一个实例，考虑其本质特性，不释放的话在单例模式下可能会更好一些，待系统使用完毕后自动回收资源也是一个不错的选择。

在实际项目中，特别是客户端开发，其实是不在乎这个实例的销毁的。因为，全局就这么一个变量，全局都要用，它的生命周期伴随着软件的生命周期，软件结束了，它也就自然而然的结束了，因为一个程序关闭之后，它会释放它占用的内存资源的，所以，也就没有所谓的内存泄漏了。但是，有以下情况，是必须需要进行实例销毁的：
1、在类中，有一些文件锁，文件句柄，数据库连接等等，这些随着程序的关闭而不会立即关闭的资源，必须要在程序关闭前，进行手动释放；
2、具有强迫症的程序员。

对于小编这种具有很强的强迫症患者来说当然也是必须析构以下的啦!

#include<iostream>
using namespace std;

#include<mutex>
#include<windows.h>
//class Lock
//{
//public:
//  Lock(mutex& mtx)
//      :_mtx(mtx)
//  {
//      _mtx.lock();
//  }
//  ~Lock()
//  {
//      _mtx.unlock();
//  }
//private:
//  Lock(const Lock&);//防止拷贝
//  Lock& operator=(const Lock&);//防止赋值
//
//  mutex& _mtx;
//};

class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率
        {
            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
            //Lock lock(_mtx);//RAII机制
            lock_guard<mutex>lock(_mtx);

            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
            {
                //_inst = new Singleton;
                Singleton* tmp = new Singleton;
                MemoryBarrier();//优化----内存栅栏，防止编译器对指令流水进行乱序优化
                _inst = tmp;
            }

            //_mtx.unlock();//解锁
        }

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
    static void DellInstance()//在某些情况才需要释放
    {
        lock_guard<mutex> lock(_mtx);//防止对象被释放多次

        if (_inst)
        {
            cout << "delete" << endl;
            delete _inst;
            _inst = NULL;//防止野指针的出现
        }
    }
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的
    ~Singleton()
    {
        //关闭文件锁，文件句柄，数据库连接等
    }

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();

    Singleton::DellInstance();
}

运行结果：
这里写图片描述

在上述情况中，我们还是没管住自己的小爪爪将单例对象释放掉了，但是如果我们在释放完之后又想调用该怎么办呢？
比如这样：

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();

    Singleton::DellInstance();

    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();

}

如此下来我们岂不是释放过早了，而且在饿汉模式下还可能会崩溃！！！

思来想去，我们知道main函数是所有线程的主线程，在它调用完成之后其他线程绝对早已退出，那么我们如果在主线程调用结束之后在对单例对象进行释放，那么绝逼是不会有任何问题的，接下来就是该想想如何实现了。
第一种释放：atexit

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();

    //Singleton::DellInstance();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    atexit(Singleton::DellInstance);//注册回调函数，在main函数之后调用析构
}

第二种释放：类中类

#include<iostream>
using namespace std;

#include<mutex>
#include<windows.h>
//class Lock
//{
//public:
//  Lock(mutex& mtx)
//      :_mtx(mtx)
//  {
//      _mtx.lock();
//  }
//  ~Lock()
//  {
//      _mtx.unlock();
//  }
//private:
//  Lock(const Lock&);//防止拷贝
//  Lock& operator=(const Lock&);//防止赋值
//
//  mutex& _mtx;
//};

class Singleton
{
public:
    static Singleton* GetInstance()// 获取唯一对象实例的接口函数
    {
        if (NULL == _inst)//双检查机制，只有创建实例的时候才进行加锁解锁来提高代码效率
        {
            //_mtx.lock();//加锁，加锁期间其余线程不能访问该临界区
            //Lock lock(_mtx);//RAII机制
            lock_guard<mutex>lock(_mtx);

            if (NULL == _inst)//只有当第一次进来_inst为空的时候才创建实例
            {
                //_inst = new Singleton;
                Singleton* tmp = new Singleton;
                MemoryBarrier();//优化----内存栅栏，防止编译器对指令流水进行乱序优化
                _inst = tmp;
            }

            //_mtx.unlock();//解锁
        }

        return _inst;//返回实例化的唯一对象
    }
    void Print()
    {
        cout << "Singleton:" <<_inst<< endl;
    }
    static void DellInstance()//在某些情况才需要释放
    {
        lock_guard<mutex> lock(_mtx);//防止对象被释放多次

        if (_inst)
        {
            cout << "delete" << endl;
            delete _inst;
            _inst = NULL;//防止野指针的出现
        }
    }
    struct GC//实现方式二：类中类
    {
        ~GC()
        {
            DellInstance();//调用析构函数
        }
    };
private:
    Singleton()//将构造函数设为私有的，防止在外部创建实例
    {}
    Singleton(const Singleton&);//将拷贝构造函数声明为私有的
    Singleton& operator=(const Singleton&);//将赋值运算符重载设置为私有的
    ~Singleton()
    {
        //关闭文件锁，文件句柄，数据库连接等
    }

    static Singleton* _inst;// 指向实例的指针定义为静态私有，这样定义静态成员函数获取对象实例 
    int _a; // 单例类里面的数据
    static mutex _mtx; // 保证线程安全的互斥锁
};

Singleton* Singleton::_inst = NULL;//给静态指针赋值
mutex Singleton::_mtx;//_mtx会调用mutex默认的无参构造函数，所以不用初始化

void TestLazy()
{
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();

    //Singleton::DellInstance();
    Singleton::GetInstance()->Print();
    Singleton::GetInstance()->Print();
    //atexit(Singleton::DellInstance);//注册回调函数，在main函数之后调用析构
}
static Singleton::GC gc;

三、饿汉模式的模拟实现

饿汉模式–简洁、高效、不用加锁、但是在某些场景下会有缺陷
实现方式一：

#include<iostream>
using namespace std;

#include<cassert>
class Singleton
    {
    public:
        static Singleton& GetInstance()
        {
            assert(_inst);
            return *_inst;
        }
        void Print()
        {
            cout << "Singleton:" << _a << endl;
        }
    protected:
        Singleton()
            :_a(0)
        {}
        Singleton(const Singleton&);
        Singleton& operator=(const Singleton&);

        static Singleton* _inst;
        int _a;
    };

    Singleton* Singleton::_inst = new Singleton;//静态成员在main函数之前初始化

    void Test()
    {
        Singleton::GetInstance().GetInstance().Print();
        Singleton::GetInstance().GetInstance().Print();
        Singleton::GetInstance().GetInstance().Print();
    }

运行结果：
这里写图片描述

实现方式二：

class Singleton1
    {
        public:
            static Singleton1& GetInstance()
            {
                static Singleton1 inst;//静态变量只会创建一次
                return inst;
            }
            void Print()
            {
                cout << "Singleton1:" << _a << endl;
            }
        protected:
            Singleton1()
                :_a(0)
            {}
            Singleton1(const Singleton1&);
            Singleton1& operator=(const Singleton1&);

            int _a;
        };

        void Test1()
        {
            Singleton1::GetInstance().GetInstance().Print();
            Singleton1::GetInstance().GetInstance().Print();
            Singleton1::GetInstance().GetInstance().Print();
        }

[Now is 1:30,fighting!!!]

snow_5288
关注
设计模式——单例模式
qq_37776015的博客
04-29 527
单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用...
单例模式详解~~单例模式详解~~
03-01
单例模式详解~~单例模式详解~~单例模式详解~~
单例模式（Singleton Pattern）详解：确保类的唯一性
qq_35803412的博客
03-16 955
单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个全局访问点来访问该实例。确保类只有一个实例。提供一个全局访问点，允许任何地方访问该唯一实例。
单例模式详解一
小白
12-08 205
单列模式的应用场景 单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建新模式。J2EE标准中的ServletContext、ServletContextConfig 等、Spring 框架应用中的ApplictionContext、数据库的连接池等都是单例形式。 饿汉式单例模式 先来看单例模式的类结构图，如图 ...
单例模式 详解
T_Y_F_的博客
12-06 558
单例模式 详解
单例模式详解 1. 什么是单例模式？ 1.1 单例模式的核心要素 1.2 为什么需要单例模式？ 2. 单例模式的实现方式 2.1 饿汉式（静态常量） 2.2 饿汉式（静态代码块） 2.3 懒汉式（线程
最新发布
04-23
单例模式详解 1. 什么是单例模式？ 1.1 单例模式的核心要素 1.2 为什么需要单例模式？ 2. 单例模式的实现方式 2.1 饿汉式（静态常量） 2.2 饿汉式（静态代码块） 2.3 懒汉式（线程不安全） 2.4 懒汉式（线程安全，...
JavaScript设计模式—单例模式详解【四种基本形式】
01-19
本文实例讲述了JavaScript设计模式—单例模式.分享给大家供大家参考，具体如下： 单例模式也称为单体模式，其中： 1，单体模式用于创建命名空间，将系列关联的属性和方法组织成一个逻辑单元，减少全局变量。 　逻辑...
PHP单例模式详解及实例代码
01-20
PHP单例模式详解 单例模式的概念 单例模式是指整个应用中某个类只有一个对象实例的设计模式。具体来说，作为对象的创建方式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统全局的提供这个实例。它...
php设计模式之单例模式详解
jkzyx123的博客
06-03 1032
单例模式（Singleton Pattern）是一种常用的软件设计模式，它确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。在PHP开发中，单例模式常用于那些需要频繁实例化但又希望限制实例数量的场景，比如数据库连接、日志记录器等，以减少资源消耗和提高效率。
【设计模式】单例模式
u011035026的博客
09-11 218
1、模式定义 作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例特别：（1）单例模式只能有一个实例。（2）单例类必须创建自己的唯一实例。（3）单例类必须向其他对象提供这一实例。 2、代码实现 （1）双重加锁方式 public class Singlnton{ private static volatile Singlnton instance; private Singlnton(){
C++实现单例模式详解
"C++中的单例模式是一个重要的设计模式，用于确保一个类只有一个实例存在，并提供全局访问点。在多种场景下，如系统日志、GUI应用、MODEM连接等，都需要用到单例模式。传统的全局变量实现方式虽然简单，但无法保证...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值