设计模式（三）单例模式

深藏阁楼爱情的钟 2022-07-13 07:25 105阅读 0赞

**单例模式**在GUI编程中比较常见，很多时候我们都只需要点击按钮只创建一个实例化的窗体，而不是每次点击按钮都创建已经实例化的窗体。所有学好单例模式还是很有用处的。单例模式的一般UML模型表示如下：

![20161230153307426][]

*  **单****例模式原理及实现**

**单****例模式的基本思想**是：保证一个类只有一个实例，并提供一个访问它的全局访问点。首先，需要保证一个类只有一个实例；在类中，要构造一个实例，就必须调用类的构造函数，如此，为了防止在外部调用类的构造函数而构造实例，需要将构造函数的访问权限标记为protected或private；最后，需要提供要给全局访问点，就需要在类中定义一个static函数，返回在类内部唯一构造的实例。

单例模式的简单实现：

#include<iostream>
    using namespace std;
    class Singleton
    {
    public:
    	static Singleton *GetInstance()
    	{
    		if(mInstance==NULL)
    			mInstance = new Singleton();
    		return mInstance;
    		//return new Singleton();
    	}
    	void show()
    	{
    		cout<<"Times of instance is: "<<count<<endl;
    	}
    	
    private:
    	static int count;
    	static Singleton * mInstance;
    	Singleton(){count++;};
    	~Singleton();
    };
    
    Singleton *Singleton::mInstance=NULL;
    int Singleton::count=0;
    
    int main()
    {
    	Singleton *obj1=Singleton::GetInstance();
    	obj1->show();
    
    	Singleton *obj2=Singleton::GetInstance();
    	obj2->show();
    
    	Singleton *obj3=Singleton::GetInstance();
    	obj3->show();
    
    	Singleton *obj4=Singleton::GetInstance();
    	obj4->show();
    	return 0;
    }

如果不进行判断，进行实例化的话：

static Singleton *GetInstance()
    	{
    		//if(mInstance==NULL)
    		//	mInstance = new Singleton();
    		//return mInstance;
    		return new Singleton();
    	}

结果对比如下：

![20161230192154829][]

## 线程安全性 ##

一般而言，还会考虑到**线程安全性**的问题**，即在类的共享变量mInstance部分会发生竞争，使得单例控制失败**。这时候需要进行同步控制，一般而言会进行互斥量的控制。进行双重加锁控制。这里可以介绍一种利用const变量进行线程安全型控制的方法，个人觉得更加简单有效。

在多线程环境中，不考虑线程安全性条件下执行单例模式：

#include<iostream>
    #include<pthread.h>
    #include<unistd.h>
    using namespace std;
    class Singleton
    {
    public:
    	static Singleton *GetInstance()
    	{
    		if(mInstance==NULL)
    			mInstance = new Singleton();
    		return (mInstance);
    	}
    	void show()
    	{
    		cout<<"Times of instance is: "<<count<<endl;
    	}
    	
    private:
    	static int count;
    	static  Singleton * mInstance;
    	Singleton(){count++;};
    	~Singleton();
    };
    
    
    
    
    void * CreateObjThread(void *args)
    {
    	Singleton *obj=Singleton::GetInstance();
    	obj->show();
    	pthread_exit ((void *)0);
    }
    
    void * CreateObjThread1(void *args)
    {
    	Singleton *obj=Singleton::GetInstance();
    	obj->show();
    	pthread_exit ((void *)0);
    }
    
    Singleton *Singleton::mInstance=NULL;
    int Singleton::count=0;
    
    int main()
    {
    	pthread_t ntid1,ntid2,ntid3;
    	int err;
    	void *thret;
    	err=pthread_create(&ntid1,NULL,CreateObjThread,NULL);
    	if(err!=0) {cout<<"thread create error"<<endl;return -1;}
    	
    	err=pthread_create(&ntid2,NULL,CreateObjThread1,NULL);
    	if(err!=0) {cout<<"thread create error"<<endl;return -1;}
    
    	err=pthread_create(&ntid3,NULL,CreateObjThread,NULL);
    	if(err!=0) {cout<<"thread create error"<<endl;return -1;}
    
    	pthread_join(ntid1,&thret);
    	pthread_join(ntid2,&thret);
    	pthread_join(ntid3,&thret);
    	
    	return 0;
    }

![20161230203536764][]

可以看出单例模式基本已经失效，因此有必要进行线程安全性的控制：

**将mInstance声明为const，这样就就算是多线程，然后在多线程启动之前完成初始化，这样就不会由于多线程造成影响：**

#include<iostream>
    #include<pthread.h>
    #include<unistd.h>
    using namespace std;
    class Singleton
    {
    public:
    	static Singleton *GetInstance()
    	{
    		if(mInstance==NULL)
    			mInstance = new Singleton();
    		return const_cast<Singleton *>(mInstance);
    	}
    	void show()
    	{
    		cout<<"Times of instance is: "<<count<<endl;
    	}
    	
    private:
    	static int count;
    	static  const Singleton * mInstance;
    	Singleton(){count++;};
    	~Singleton();
    };
    
    
    
    
    void * CreateObjThread(void *args)
    {
    	Singleton *obj=Singleton::GetInstance();
    	obj->show();
    	pthread_exit ((void *)0);
    }
    
    void * CreateObjThread1(void *args)
    {
    	Singleton *obj=Singleton::GetInstance();
    	obj->show();
    	pthread_exit ((void *)0);
    }
    
    const Singleton *Singleton::mInstance=new Singleton();
    int Singleton::count=0;
    
    int main()
    {
    	pthread_t ntid1,ntid2,ntid3;
    	int err;
    	void *thret;
    	err=pthread_create(&ntid1,NULL,CreateObjThread,NULL);
    	if(err!=0) {cout<<"thread create error"<<endl;return -1;}
    	
    	err=pthread_create(&ntid2,NULL,CreateObjThread1,NULL);
    	if(err!=0) {cout<<"thread create error"<<endl;return -1;}
    
    	err=pthread_create(&ntid3,NULL,CreateObjThread,NULL);
    	if(err!=0) {cout<<"thread create error"<<endl;return -1;}
    
    	pthread_join(ntid1,&thret);
    	pthread_join(ntid2,&thret);
    	pthread_join(ntid3,&thret);
    	
    	return 0;
    }

![20161230204143422][]

[20161230153307426]: /images/20220713/f6d05a9b0aad436cb2b6fe5a09df3d2d.png
[20161230192154829]: /images/20220713/08ed2306e33d4606b1e2b2cbf868d392.png
[20161230203536764]: /images/20220713/a79d57018c7441199b99b8d0eebb2e81.png
[20161230204143422]: /images/20220713/959ccb03276541d08a7e9fdc27a53662.png