设计模式——单例模式C++实现

最新推荐文章于 2024-05-19 17:18:13 发布
最新推荐文章于 2024-05-19 17:18:13 发布
阅读量657 收藏
点赞数
分类专栏： 设计模式 C/C++ 文章标签： C++ 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Linux_ever/article/details/51707255
版权

引出问题：

设计一个类，我们只能生成该类的一个对象实例。

不好的解法：只适用于单线程环境

因为该类只能生成一个对象实例，那么该类的构造函数必须是私有的，从而避免他人创建实例。在需要的时候创建该类的一个对象。

下面是程序实现：

/*************************************************************************
	> File Name: SigleInstance.cpp
	> Author: 
	> Mail: 
	> Created Time: Sat 18 Jun 2016 06:44:44 PM CST
 ************************************************************************/

#include <iostream>
using namespace std;


//只能生成一个类对象的类
class SigleInstance
{
public:
    //指向类的一个实例对象
    static SigleInstance * instance;
private:
    //私有的构造函数
    SigleInstance(){cout << "执行SigleInstance 构造函数" << endl;}
public:
    //创建一个实例对象
    static SigleInstance * getSigleInstance(){
        if(instance == NULL)
            instance = new SigleInstance();

        return instance;
    }
};


//初始化静态成员变量
SigleInstance * SigleInstance::instance = NULL;

//测试函数
int main()
{

    SigleInstance * SigleInstance1 = SigleInstance::getSigleInstance();
    SigleInstance * SigleInstance2 = SigleInstance::getSigleInstance();
    SigleInstance * SigleInstance3 = SigleInstance::getSigleInstance();


    if(SigleInstance1 == SigleInstance2){
        cout << "SigleInstance1 == SigleInstance2" << endl;
    }

    if(SigleInstance1 == SigleInstance3){
        cout << "SigleInstance1 == SigleInstance3" << endl;
    }

    return 0;
}


下面是程序的输出：
执行SigleInstance 构造函数
SigleInstance1 == SigleInstance2
SigleInstance1 == SigleInstance3
从程序的输出可以看出，SigleInstance1和SigleInstance2和SigleInstance3指向的都是同一个对象。

不好的解法2：可以在多线程环境下工作，但是效率比较低

解法1中的代码在单线程的情况下工作正常，但在多线程的环境下就有问题了。如果两个线程同时运行判断instance是否为NULL的if语句，并且instance实例还没有创建时，那么两个线程都会创建一个实例，那么此时就不满足单例模式的要求了。

为了保证在多线程的环境下我们还是只能得到一个实例，需要加上一个同步锁。

下面是实现的程序：

/*************************************************************************
	> File Name: SigleInstance.cpp
	> Author: 
	> Mail: 
	> Created Time: Sat 18 Jun 2016 06:44:44 PM CST
 ************************************************************************/

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;


//只能生成一个类对象的类
class SigleInstance
{
public:
    //指向类的一个实例对象
    static SigleInstance * instance;

    //定义一个互斥锁变量
    static pthread_mutex_t instanceMutex;

private:
    //私有的构造函数
    SigleInstance(){cout << "执行SigleInstance 构造函数" << endl;}
public:
    //创建一个实例对象
    static SigleInstance * getSigleInstance(){
        //获得互斥锁
        pthread_mutex_lock(&instanceMutex);

        if(instance == NULL)
            instance = new SigleInstance();

        //睡眠仅仅为了测试其它线程是否处于等待状态，真正的程序是不需要该延迟的
        sleep(3);

        //释放互斥锁
        pthread_mutex_unlock(&instanceMutex);

        return instance;
    }
};


//初始化静态成员变量
SigleInstance * SigleInstance::instance = NULL;
//初始化互斥锁变量
pthread_mutex_t SigleInstance::instanceMutex = PTHREAD_MUTEX_INITIALIZER;


//线程要执行的函数
void * threadFun(void *arg)
{
    SigleInstance * instance = SigleInstance::getSigleInstance();
    cout << "theread" << dec << pthread_self() << ", instance's address = " << hex << instance << endl;

    pthread_exit(NULL);
}

//测试函数
int main()
{
    const int NUM = 3;
    pthread_t threadId[NUM];

    //创建NUM个线程
    for(int i = 0; i < NUM; ++i){
        pthread_create(&threadId[i], NULL, threadFun, NULL);
    }

    for(int i = 0; i < NUM; ++i){
        pthread_join(threadId[i], NULL);
    }

    return 0;
}

下面是程序的输出：

执行SigleInstance 构造函数
theread139706800436992, instance's address = 0x7f10000008c0
theread139706808829696, instance's address = 0x7f10000008c0
theread139706817222400, instance's address = 0x7f10000008c0

从输出结果可以看出，执行了一个构造函数，每个线程获得的实例对象的地址都是相同的，表明只有一个实例对象。并且每个线程之间的等待时间为2秒。

在上面的程序中，因为每个时刻只能有一个线程获得互斥锁，当第一个线程获得互斥锁的时候，其它线程只能等待。当第一个线程获得互斥锁后，发现实例还没有创建时，它会创建一个实例。接着第一个线程释放互斥锁，此时第二个线程可以获得互斥锁，并运行下面的代码，但是此时已经创建了一个实例，所以，第二个线程直接返回，不会再创建一个实例。这样就可以保证在多线程的环境下也只能创建一个实例。

但是解法2不是很完美，因为每次通过获取实例对象的时候都会试图获得互斥锁，但是加锁和解锁是非常耗时的操作，我们应该尽量避免加锁和解锁的操作。具体改进看下面解法3。

改进解法2：加锁前后两次判断实例是否已经存在

下面是实现的程序： 
/*************************************************************************
	> File Name: SigleInstance.cpp
	> Author: 
	> Mail: 
	> Created Time: Sat 18 Jun 2016 06:44:44 PM CST
 ************************************************************************/

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;


//只能生成一个类对象的类
class SigleInstance
{
public:
    //指向类的一个实例对象
    static SigleInstance * instance;

    //定义一个互斥锁变量
    static pthread_mutex_t instanceMutex;

private:
    //私有的构造函数
    SigleInstance(){cout << "执行SigleInstance 构造函数" << endl;}
public:
    //创建一个实例对象
    static SigleInstance * getSigleInstance(){

        //如果实例没有创建，则加锁并创建实例
        //如果实例已经创建，则直接返回该实例的指针
        if(instance == NULL){
            //获得互斥锁
            pthread_mutex_lock(&instanceMutex);

            if(instance == NULL)
                instance = new SigleInstance();

            //睡眠仅仅为了测试其它线程是否处于等待状态，真正的程序是不需要该延迟的
            sleep(3);

            //释放互斥锁
            pthread_mutex_unlock(&instanceMutex);
        }

        return instance;
    }
};


//初始化静态成员变量
SigleInstance * SigleInstance::instance = NULL;
//初始化互斥锁变量
pthread_mutex_t SigleInstance::instanceMutex = PTHREAD_MUTEX_INITIALIZER;


//线程要执行的函数
void * threadFun(void *arg)
{
    SigleInstance * instance = SigleInstance::getSigleInstance();
    cout << "theread" << dec << pthread_self() << ", instance's address = " << hex << instance << endl;

    pthread_exit(NULL);
}

//测试函数
int main()
{
    const int NUM = 3;
    pthread_t threadId[NUM];

    //创建NUM个线程
    for(int i = 0; i < NUM; ++i){
        pthread_create(&threadId[i], NULL, threadFun, NULL);
    }

    for(int i = 0; i < NUM; ++i){
        pthread_join(threadId[i], NULL);
    }

    return 0;
}

下面是程序的输出：

执行SigleInstance 构造函数
theread139991850669824, instance's address = 0x7f525c0008c0
theread139991859062528, instance's address = 0x7f525c0008c0
theread139991842277120, instance's address = 0x7f525c0008c0

从程序的输出情况来看，线程139991842277120是创建该类实例的线程，因为，它经过了睡眠，所以是最后输出。另外两个线程输出比较早，在线程139991842277120创建完实例之后，另外两个线程就返回了，这两个线程没有进行加锁和解锁操作。

解法4：利用静态变量的初始化顺序

这种方法其实是单例模式中的饿汉式方式，上面的方法是单例模式中的懒汉式方式。

这种方法的实例对象，是在类变量instance初始化的时候就创建了该实例，也就是说程序一开始运行，

参考文章：

设计模式——单例模式java实现

下面是程序实现：

/*************************************************************************
	> File Name: SigleInstance.cpp
	> Author: 
	> Mail: 
	> Created Time: Sat 18 Jun 2016 06:44:44 PM CST
 ************************************************************************/

#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;


//只能生成一个类对象的类
class SigleInstance
{
public:
    //指向类的一个实例对象
    static SigleInstance * instance;

private:
    //私有的构造函数
    SigleInstance(){cout << "执行SigleInstance 构造函数" << endl;}
public:
    //创建一个实例对象
    static SigleInstance * getSigleInstance(){
        return instance;
    }
};


//初始化静态成员变量,此时直接创建一个实例对象
SigleInstance * SigleInstance::instance = new SigleInstance();


//线程要执行的函数
void * threadFun(void *arg)
{
    SigleInstance * instance = SigleInstance::getSigleInstance();
    cout << "theread" << dec << pthread_self() << ", instance's address = " << hex << instance << endl;

    pthread_exit(NULL);
}

//测试函数
int main()
{
    cout << "main start..." << endl;

    const int NUM = 3;
    pthread_t threadId[NUM];

    //创建NUM个线程
    for(int i = 0; i < NUM; ++i){
        pthread_create(&threadId[i], NULL, threadFun, NULL);
    }

    for(int i = 0; i < NUM; ++i){
        pthread_join(threadId[i], NULL);
    }

    return 0;
}

下面是程序的输出：

执行SigleInstance 构造函数
main start...
theread140681870264064, instance's address = 0xbaa010
theread140681878656768, instance's address = 0xbaa010
theread140681887049472, instance's address = 0xbaa010

从输出结果可以看出，在main函数开始执行之前，类实例已经创建完了。


更多详情，请前往本人博客网站：个人博客网站

readyao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——单例模式-附件资源
03-05
C++设计模式——单例模式-附件资源
【C++】C++ 单例模式总结（5种单例实现方法）
热门推荐
unonoi的博客
11-04 8万+
C++ 单例模式的几种实现方式。
单例模式——C++实现
weixin_52152452的博客
02-25 939
使用C++实现单例模式的饿汉模式、懒汉模式(线程安全)
C++实现单例模式(详细版)
最新发布
ReLesEason的博客
05-19 1444
以循序渐进地方式详细介绍各种单例模式C++实现方法（详细写了6种方法）及其特点，并给出了测试案例
C++单例模式的几种实现
恋恋风辰的技术博客
03-20 6067
本文介绍C++单例模式的集中实现方式，以及利弊 局部静态变量方式 //通过静态成员变量实现单例 //懒汉式 class Single2 { private: Single2() { } Single2(const Single2 &) = delete; Single2 &operator=(const Single2 &) = delete; public: static Single2 &GetInst() {
C++ 单例模式
jfkidear的专栏
03-20 961
C++ 单例模式 Arkin Mechanic . Keep coding. ​关注他 27 人赞同了该文章 1. 什么是单例模式 单例模式(Singleton Pattern，也称为单件模式)，使用最广泛的设计模式之一。其意图是保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。 定义一个单例类： 私有化它的构造函数，以防止外界创建单例类的对象； ...
C++单例模式实现
一个不知名码农的专栏
09-02 3176
单例模式 单例模式：要求类只有一个对象实例，数据库连接池、线程池以及Windows任务管理器都是单例模式的应用。 那么如何去实现一个单例模式呢？C++中有5种实现的方式，首先从最简单说起 1. 单线程实现 常规写法 class Singleton{ public: static Singleton* getInstance() { if(_instance == nullptr) ...
设计模式——单例模式
04-16
单例模式是软件设计模式中的一种经典模式，它在许多实际场景中被广泛使用，尤其在需要控制类的实例只有一个的情况下。单例模式确保无论在程序的任何地方，只要通过特定方式请求该类的实例，始终只会返回同一个对象。...
C++中的单例模式介绍
01-21
《设计模式》一书中给出了一种很不错的实现，定义一个单例类，使用类的私有静态指针变量指向类的唯一实例，并用一个公有的静态方法获取该实例。 单例模式通过类本身来管理其唯一实例，这种特性提供了解决问题的方法...
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
单例模式实现（C++）
crazyfox的博客
08-13 718
1. 饿汉式 /** * 单例模式饿汉式实现 */ class Singleton { private: Singleton() {} //构造函数私有 static Singleton instance; //实例static，并且是private public: static Singleton& getInstance() { return instance; // 返回实例引用 } }; 优点： 将耗时的初始化提前，不会出现首次调用性
单例模式4种实现方式C++
笔记的博客
08-21 1051
假设在reorder的情况下：线程1走到赋值，但还没调用构造的阶段，而线程2进来判断m_instance，此时它已经被复制 所以不为空，这时候线程2就直接返回m_instance，但事实上它还没构造出来……因为编译器优化，指令的执行顺序可能reorder（CPU执行指令的层次，而且线程是在指令层次抢时间片的） ，可能变成这样：分配内存->赋值->调用构造(理想应该是：分配内存->调用构造->赋值）这样，编译时在编译的时候就知道，这个变量的整个赋值过程不能reorder，需要按照常规的流程走。...
单例模式c++实现
hou19975418的博客
01-29 810
单例模式学习笔记
【设计模式】单例模式 C++实现
yaodaoji的博客
05-11 1412
一、概念 单例模式（Singleton）: 保证一个类仅有一个实例，并提供一个访问它的全局访问点。 通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。 二、实现方法 单例模式有三种实现方法：懒汉式、双重锁定（Double-Check-Locking）、饿汉式。 1. 懒汉式 先看代码： class Singleton //实现单例模式的类 {
C++如何实现单例模式？
Tattoo的博客
02-25 7406
这是在看侯捷C++视频的时候，他提出的一个问题，称之为单例模式（singleton），有两种实现方式（懒汉与饿汉），还有多线程，使用场景（工厂模式）等等一些相关的东西，更多了解可以去百度一下。在此就简单做一个总结。 方法一共有n个。根据侯老师所言，目前这两种是比较好的实现方式，所以找出来与大家分享一下。一是： #include&lt;iostream&gt; #include&lt;vec...
C++实现单例模式
u012732168的博客
04-16 1万+
C++单例模式
C++实现Gof的23种设计模式：Factory模式解析与实现
"C++实现的23种设计模式讲解及示例" 设计模式是一种在特定情境下解决问题的可重用方案，它已经被广泛应用于软件工程领域。本资源主要聚焦于GoF（Gang of Four）提出的23种经典设计模式，并通过C++语言进行实现，以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值