单例模式

最新推荐文章于 2021-04-28 18:58:22 发布
最新推荐文章于 2021-04-28 18:58:22 发布
阅读量225 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010710458/article/details/80670668
版权

参考

什么是单例模式

应该怎样去创建一个唯一的变量或对象?在基于对象的设计中我们可以通过创建一个全局变量或对象来实现，在面向对象和面向过程结合的设计范式（如C++中） 中，我们也还是可以通过一个全局变量实现这一点。 但是当我们遇到了纯粹的面向对象范式（Java）中，这一点可能就只能是通过Singleton模式来实现了。

实现

通过维护一个static的成员变量来记录这个唯一的对象实例。通过提供一个staitc的接口instance来获得这个唯一的实例。因为都是static，所以这些类中的对象或者接口都是其实例化的所有对象公共拥有的唯一一份。

1、线程不安全的单例，且在对象生命周期过后，对象并没有析构。

/*
线程不安全的单例，且在对象生存期到时候不会被析构。
*/
class Singleton{
public:
    static Singleton *GetInstance(){//静态函数，提供全局访问点
        if(instance_ == NULL){
            instance_ = new Singleton();
        }
        return instance_;
    }
private:
    Singleton(){//私有化默认构造函数,只能在GetInstance中调动，外部不能new对象。
        cout << "Singleton Init..." << endl;
    }
    Singleton(const Singleton &rhs);//禁止拷贝构造  a(b)这种形式
    Singleton &operator=(const Singleton &rhs);//禁止赋值运算符 a = b这种形式
    static Singleton *instance_;//静态对象
};
Singleton *Singleton::instance_ = NULL;//静态成员初始化

int main(void){

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();//静态可以直接获取
    return 0;
}//仅仅输出一个Singleton Init...

Singleton单例类特征

  • 它有一个指向唯一实例的静态指针instance_，并且是私有的；
  • 它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例
  • 它的构造函数是私有的，这样就不能从别处创建该类的实例。
  • 拷贝构造函数和赋值运算符都私有，使得不允许拷贝和赋值。

大多数时候，这样的实现都不会出现问题。有经验的读者可能会问，instance_指向的空间什么时候释放呢？更严重的问题是，该实例的析构函数什么时候执行？
如果在类的析构行为中有必须的操作，比如关闭文件，释放外部资源，那么上面的代码无法实现这个要求。我们需要一种方法，正常的删除该实例。
程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。如下面的代码中的CGarbo类（Garbo意为垃圾工人）

2、线程不安全的单例，且在对象生命周期过后，对象析构。

class Singleton{
public:
    static Singleton *GetInstance(){//静态函数，提供全局访问点
        if(instance_ == NULL){
            instance_ = new Singleton();
        }
        return instance_;
    }
    ~Singleton(){
        cout << "~Singleton..." << endl;
    }

    class Garbo{//辅助类，主要用其析构函数删除实例对象
    public:
        ~Garbo(){
            if(instance_ != NULL)
                delete instance_;
        }
    };

private:
    Singleton(){//私有化默认构造函数,只能在GetInstance中调动，外部不能new对象。
        cout << "Singleton Init..." << endl;
    }
    Singleton(const Singleton &rhs);//禁止拷贝构造  a(b)这种形式
    Singleton &operator=(const Singleton &rhs);//禁止赋值运算符 a = b这种形式
    static Singleton *instance_;//静态对象
    static Garbo garbo_;//利用对象确定性析构
};
Singleton *Singleton::instance_ = NULL;//静态成员初始化
Singleton::Garbo Singleton::garbo_;//静态默认初始化

int main(void){

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();//静态可以直接获取
    return 0;
}

这里写图片描述
利用静态嵌套对象的确定性析构会调用Garbo类的析构函数，在析构函数内delete单例类的指针。

3、上述析构过于麻烦可以使用局部静态对象的引用解决
局部静态对象仅仅初始化一次存储在数据区，并且在程序退出的时候，会自动析构局部对象。所以完全满足单例的全部条件。

class Singleton{
public:
    static Singleton &GetInstance(){//静态函数，提供全局访问点
        static Singleton instance_;//静态局部对象，仅仅初始化一次
        return instance_;
    }
    ~Singleton(){
        cout << "~Singleton..." << endl;
    }

private:
    Singleton(){//私有化默认构造函数,只能在GetInstance中调动，外部不能new对象。
        cout << "Singleton Init..." << endl;
    }
    Singleton(const Singleton &rhs);//禁止拷贝构造  a(b)这种形式
    Singleton &operator=(const Singleton &rhs);//禁止赋值运算符 a = b这种形式
};

int main(void){

    Singleton &s1 = Singleton::GetInstance();
    Singleton &s2 = Singleton::GetInstance();//静态可以直接获取，系统最后会自动调用析构函数
    return 0;
}

4、线程安全的单例
只有在对象创建的时候，才有可能出现线程不安全。两个线程同时竞争创建。于是有了下面两种解决线程安全的问题。
1、饿汉模式（在某些场景下受到限制）
在main函数开始的时候即创建对象，其他就是读取对象了，那么饿汉模式是线程安全的。

2、懒汉模式(适用于各种场景)，使用互斥锁(一种使用原始锁，二种就是使用RALL手法)

直接使用互斥量，并且采用了atexit，注册在程序结束的时候，调用析构函数。

class Singleton{
public:
    static Singleton *GetInstance(){//静态函数，提供全局访问点
        if(instance_ == NULL){
            pthread_mutex_lock(&lock);
            instance_ = new Singleton();
            atexit(Destory);//注册程序结束的时候，调用Destory析构对象，避免了再次使用garbo类
            pthread_mutex_unlock(&lock);
        }
        return instance_;
    }
    ~Singleton(){
        cout << "~Singleton..." << endl;
    }


private:
    Singleton(){//私有化默认构造函数,只能在GetInstance中调动，外部不能new对象。
        cout << "Singleton Init..." << endl;
    }
    Singleton(const Singleton &rhs);//禁止拷贝构造  a(b)这种形式
    Singleton &operator=(const Singleton &rhs);//禁止赋值运算符 a = b这种形式
    static void Destory(){
        delete instance_;
    }
    static Singleton *instance_;//静态对象
    static pthread_mutex_t lock;//静态锁对象
};
pthread_mutex_t Singleton::lock = PTHREAD_MUTEX_INITIALIZER;//初始化锁
Singleton *Singleton::instance_ = NULL;//静态成员初始化

int main(void){

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();//静态可以直接获取，系统最后会自动调用析构函数
    return 0;
}

将锁使用RALL手法封装起来，简化锁的使用。

/*
简单封装Mutex的构造和析构、加锁和解锁
*/
#include<pthread.h>
#include<iostream>
using namespace std;

class MutexLock
{
public:
    MutexLock()
    {
        pthread_mutex_init(&mutex_, NULL);
    }

    ~MutexLock()
    {
        pthread_mutex_destroy(&mutex_);
    }

    void lock()
    {
        pthread_mutex_lock(&mutex_);
    }

    void unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }

private:
    MutexLock(const MutexLock&);//禁止拷贝
    MutexLock& operator=(const MutexLock&);//禁止赋值
    pthread_mutex_t mutex_;//锁
};

/*
通过引用将RALL手法封装锁
*/


class MutexLockGuard
{
public:
  explicit MutexLockGuard(MutexLock& mutex):mutex_(mutex)//构造加锁，且禁止通过此构造函数类型转换
  {
    mutex_.lock();
  }
  ~MutexLockGuard()//析构释放锁
  {
    mutex_.unlock();
  }
private:
  MutexLockGuard(const MutexLockGuard&);//禁止拷贝
  MutexLockGuard& operator=(const MutexLockGuard&);//禁止赋值
  MutexLock& mutex_;//定义一个锁的引用
};

#define MutexLockGuard(x) error "Missing guard object name"//防止产生匿名对象，生命周期非常短，没有锁住。
//防止产生临时对象

class Singleton{
public:
    static Singleton *GetInstance(){//静态函数，提供全局访问点
        if(instance_ == NULL){
            //MutexLockGuard lock(Singleton::mutex);//创建一个匿名对象，并通过mutex_初始化，析构
            MutexLockGuard  lock(mutex);
            instance_ = new Singleton();
            atexit(Destory);//注册程序结束的时候，调用Destory析构对象，避免了再次使用garbo类
        }
        return instance_;
    }
    ~Singleton(){
        cout << "~Singleton..." << endl;
    }
private:
    Singleton(){//私有化默认构造函数,只能在GetInstance中调动，外部不能new对象。
        cout << "Singleton Init..." << endl;
    }
    Singleton(const Singleton &rhs);//禁止拷贝构造  a(b)这种形式
    Singleton &operator=(const Singleton &rhs);//禁止赋值运算符 a = b这种形式
    static void Destory(){
        delete instance_;
    }
    static Singleton *instance_;//静态对象
    static MutexLock mutex;//互斥锁，此时没有初始化，需要在下面初始化  调用了默认构造函数
};
/*
静态变量必须初始化
*/
Singleton *Singleton::instance_ = NULL;//静态成员初始化
MutexLock Singleton::mutex;//相当于调用默认构造函数初始化


int main(void){

    Singleton *s1 = Singleton::GetInstance();
    Singleton *s2 = Singleton::GetInstance();//静态可以直接获取，系统最后会自动调用析构函数
    return 0;
}

时刻注意静态对象必须初始化，才会调用其默认构造函数。

4、线程安全的单例模板

/*
简单封装Mutex的构造和析构、加锁和解锁
*/
#include<pthread.h>
#include<iostream>
using namespace std;

class MutexLock
{
public:
    MutexLock()
    {
        pthread_mutex_init(&mutex_, NULL);
    }

    ~MutexLock()
    {
        pthread_mutex_destroy(&mutex_);
    }

    void lock()
    {
        pthread_mutex_lock(&mutex_);
    }

    void unlock()
    {
        pthread_mutex_unlock(&mutex_);
    }

private:
    MutexLock(const MutexLock&);//禁止拷贝
    MutexLock& operator=(const MutexLock&);//禁止赋值
    pthread_mutex_t mutex_;//锁
};

/*
通过引用将RALL手法封装锁
*/

class MutexLockGuard
{
public:
  explicit MutexLockGuard(MutexLock& mutex):mutex_(mutex)//构造加锁，且禁止通过此构造函数类型转换
  {
    mutex_.lock();
  }
  ~MutexLockGuard()//析构释放锁
  {
    mutex_.unlock();
  }
private:
  MutexLockGuard(const MutexLockGuard&);//禁止拷贝
  MutexLockGuard& operator=(const MutexLockGuard&);//禁止赋值
  MutexLock& mutex_;//定义一个锁的引用
};

#define MutexLockGuard(x) error "Missing guard object name"//防止产生匿名对象，生命周期非常短，没有锁住。
//防止产生临时对象
class test{
public:
    test(){
        cout << "test.." << endl;
    }
    ~test(){
        cout << "~test.." << endl;
    }
};

template <typename T>
class Singleton{
public:
    static T *GetInstance(){//静态函数，提供全局访问点
        if(instance_ == NULL){
            //MutexLockGuard lock(Singleton::mutex);//创建一个匿名对象，并通过mutex_初始化，析构
            MutexLockGuard  lock(mutex);
            instance_ = new T();
            atexit(Destory);//注册程序结束的时候，调用Destory析构对象，避免了再次使用garbo类
        }
        return instance_;
    }
    ~Singleton(){
        cout << "~Singleton..." << endl;
    }
private:
    Singleton(){//私有化默认构造函数,只能在GetInstance中调动，外部不能new对象。
        cout << "Singleton Init..." << endl;
    }
    Singleton(const Singleton &rhs);//禁止拷贝构造  a(b)这种形式
    Singleton &operator=(const Singleton &rhs);//禁止赋值运算符 a = b这种形式
    static void Destory(){
        delete instance_;
    }
    static T *instance_;//静态对象
    static MutexLock mutex;//互斥锁，此时没有初始化，需要在下面初始化  调用了默认构造函数
};
/*
静态变量必须初始化
*/
template <typename T>
T *Singleton<T>::instance_ = NULL;//静态成员初始化

template <typename T>
MutexLock Singleton<T>::mutex;//相当于调用默认构造函数初始化


int main(void){

    Singleton<test>::GetInstance();
    Singleton<test>::GetInstance();
    return 0;
}

这里写图片描述

有时需要偏执狂
关注
专栏目录
RALL 与 智能指针
BlackMonkeyHH的博客
10-19 1202
什么是RALL思想及其应用，智能指针的理解与实现。
【项目】使用C++11手写数据库连接池
最新发布
weixin_46272577的博客
10-09 1056
项目链接。
C++中的单例模式
编程资料大全
04-14 1321
单例模式也称为单件模式、单子模式，可能是使用最广泛的设计模式。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。 单例模式有许多种实现方法，在C++中，甚至可以直接用一个全局变量做到这一点，...
RAII手法
程序道 -Learning, Thinking and Coding <存储知识的金库>
03-30 1457
如何确保资源一定会被释放（即便发生异常），这在D里面对应的是scope(exit)，在Java里面对应的是finally，在C#   里面对应的是scoped using。 简而言之就是，不管当前作用域以何种方式退出，某某操作（通常是资源释放）都一定要被执行。 这个问题的答案其实C++程序员们应该耳熟能详了：RAII。RAII是C++最为强大的特性之一。在C++里面，局部变量的析构函数刚好满足
单例模式简介及由它引出的JAVA局部静态变量问题
sd_zhuzhipeng的专栏
07-05 1829
单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供实例。 单例模式类的特点： 只能有一个实例；自己创建这个实例；整个系统都使用这个实例。 先看一般的单例模式类，类名为SingletonClass，定义如下：
43丨单例模式（下）：如何设计实现一个集群环境下的分布式单例模式？1
08-03
单例模式是一种设计模式，旨在确保一个类只有一个实例，并提供全局访问点。在单例模式中，类的构造函数是私有的，防止外部直接创建对象，而是通过静态方法获取该类的唯一实例。单例模式的唯一性通常是在进程范围内，...
浅谈Spring单例Bean与单例模式的区别
08-28
"浅谈Spring单例Bean与单例模式的区别" 本文主要介绍了Spring单例Bean与单例模式的区别，通过对比两者的定义、实现机制和应用场景，帮助读者更好地理解这两种概念的异同。 一、单例模式的定义和实现 单例模式是一...
JS 设计模式之：单例模式定义与实现方法浅析
11-21
本文实例讲述了JS 设计模式之：单例模式定义与实现方法。分享给大家供大家参考，具体如下： 良好的设计模式可以显著提高代码的可读性，降低复杂度和维护成本。笔者打算通过几篇文章通俗地讲一讲常见的或者实用的设计...
使用单例模式创建学生管理系统（饿汉式、懒汉式）
04-28
单例模式是软件设计模式中的一种，它的主要目的是确保一个类只有一个实例，并提供一个全局访问点。在Java或类似的面向对象编程语言中，单例模式常用于管理共享资源，如数据库连接池、线程池或者配置文件等。在这个...
java 单例模式（懒汉式与饿汉式）
08-29
Java 单例模式（懒汉式与饿汉式） Java 单例模式是一种常用的软件设计模式，在它的可信结构中只包含一个被实例化单例的特殊类。通过单例设计模式可以把整系统中的一个类只有一个实例。单例设计模式又分为两种方式，...
关于单例模式，你应该了解这些
世纪末的架构师的博客
04-28 2582
文章目录前言一、单例模式的定义1、单例模式通用类图2、单例模式通用代码总结 前言 开始学习Java设计模式时第一个学习的模式是单例模式，参考书籍为《设计模式之禅》第2版，在此做一个记录以及学习心得，便于以后进行回顾 提示：以下是本篇文章正文内容，下面案例可供参考 一、单例模式的定义 单例模式： Ensure a class has only one instance, and provide a global point of access to it. （确保某一个类只有一个实例，而且自行实例化并向
C++单例模式 lock_guard+mutex+Garbo，绝对完整+清晰
znHD的博客
09-05 1108
class Singleton { public: static Singleton* getInstance() { if (instance == nullptr) { unique_lock&lt;mutex&gt; lg(mtx); if (instance == nullptr) instance = new Singleton; } retur...
对单例设计模式的学习（一） --饿汉式：将对象建立在静态区的单例模式
这是一个博客
03-29 455
个人对单例模式的理解： 单例模式的设计是为了实现一个类只能有一个对象的情况，例如对于一个服务器而言，数据库类可以设计成单例模式的，保证数据传输的准确性。单例模式一般用于避免实例被重复创建，多个实例同时存在会产生逻辑错乱的场合，且单例模式较节约内存空间（因为只有一个对象）。 单例模式的实现思路： 将构造函数，赋值重载运算符，拷贝构造函数这三个会产生新对象的方法设置为private权限，以此来防止对象...
RALL机制的线程锁
AlwaySimple的博客
01-10 1148
1.RAll机制   RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。 2.RAll机制的...
C++ Rall机制详解
热门推荐
越努力越幸运—liupu
04-04 1万+
RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。 那么到底什么是 RALL 机制
实际代码或者项目中用到的设计模式
一个菜鸟的博客
03-31 3320
1、Moudul里面实现的单例模式 2、STL里面的迭代器模式 3、STL里面的适配器模式
工厂模式
一个菜鸟的博客
06-12 573
什么是设计模式 某类软件设计的惯用模式，通过这种模式设计，代码可复用率高，容易看出。 常用的设计模式
建造者模式
一个菜鸟的博客
06-13 503
介绍 例如建造小人，一共需建造6个部分，头部、身体、左右手、左右脚。与工厂模式不同，建造者模式是在导向者的控制下(传入参数)一步一步构造出不同的产品(但是内部建造顺序都是稳定的)。当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建， 由于在每一步的构造过程中 可以引入参数，使...
原型模式
一个菜鸟的博客
06-13 302
浅拷贝和深拷贝 拷贝构造函数调用的条件有以下几个 用类的一个对象初始化该类的另一个对象时 如果函数的形参是类的对象,调用函数时,进行形参和实参结合时. 如果函数的返回值是类的对象,函数执行完成返回调用者时. 需要产生一个临时类对象时。 深和浅定义了拷贝构造函数的行为。 当为浅拷贝时候，则拷贝构造函数拷贝类中静态(区别与动态分配，不是指的static)或动态(指针，指向区域动态分配)变...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

有时需要偏执狂

请我喝咖啡

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值