设计模式（C++）

一、单例模式（Singleton）

        Singleton 模式是设计模式中最为简单、最为常见、最容易实现，也是最应该熟悉和掌握的模式。单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。

结构图：

 在 Singleton 模式的结构图中可以看到，我们通过维护一个 static 的成员变量来记录这个唯一的对象实例。通过提供一个 staitc 的接口 instance 来获得这个唯一的实例。

应用场景

 在应用系统开发中，我们常常有以下需求：

• 在多个线程之间，比如初始化一次socket资源；比如servlet环境，共享同一个资源或者操作同一个对象
• 在整个程序空间使用全局变量，共享资源
• 大规模系统中，为了性能的考虑，需要节省对象的创建时间等等。

使用方法

a) 构造函数私有化（设置为private） =>防止从类外调用构造函数，保证在任何情况下只生成一个实例；

b) 提供一个全局的静态方法GetInstance（全局访问点） =>便于提供从类外部获取单例类的唯一实例的方法；

c) 在类中定义一个静态指针，指向本类的变量的静态变量指针。

懒汉单例

#include <iostream>
using namespace std;
 
//懒汉式
class Singelton{
private:
        Singelton()
        {
              m_singer = NULL;
              m_count = 0;
              cout << "构造函数Singelton ... do" << endl;
        } 
public:
        static Singelton *getInstance()
        {
                if (m_singer == NULL ) //懒汉式：1 每次获取实例都要判断2 多线程会有问题
                {
                      m_singer = new Singelton;
                }
                return m_singer;
        }
        static void printT()
        {
              cout << "m_count: " << m_count << endl;
        }
 
private:
        static Singelton *m_singer;
        static int m_count;
}; 
Singelton *Singelton::m_singer = NULL; //懒汉式 并没有创建单例对象
int Singelton::m_count = 0;
void main(){
       cout << "演示 懒汉式" << endl;
       Singelton *p1 = Singelton::getInstance(); //只有在使用的时候，才去创建对象。
       Singelton *p2 = Singelton::getInstance();
       if (p1 != p2){
             cout << "不是同一个对象" << endl;
       }
       else{
             cout << "是同一个对象" << endl;
       }
       p1->printT();
       p2->printT();
       system("pause");
       return ;
}

饿汉单例

//饿汉式
 
class Singelton2
 
{
 
private:
 
        Singelton2()
 
        {
 
                m_singer = NULL;
 
                m_count = 0;
 
                cout << "构造函数Singelton ... do" << endl;
 
        }
 
 
 
public:
 
        static Singelton2 *getInstance()
 
        {
 
             return m_singer;
 
        }
 
        static void Singelton2::FreeInstance()
 
        {
 
                if (m_singer != NULL)
 
                {
 
                        delete m_singer;
 
                        m_singer = NULL;
 
                        m_count = 0;
 
              }
 
        }
 
        static void printT()
 
        {
 
              cout << "m_count: " << m_count << endl;
 
        }
 
 
 
private:
 
        static Singelton2 *m_singer;
 
        static int m_count;
 
};
 
 
 
Singelton2 *Singelton2::m_singer = new Singelton2; //不管你创建不创建实例，均把实例new出来
 
int Singelton2::m_count = 0;
 
 
 
void main()
 
{
 
        cout << "演示 饿汉式" << endl;
 
 
 
        Singelton2 *p1 = Singelton2::getInstance(); //只有在使用的时候，才去创建对象。
 
        Singelton2 *p2 = Singelton2::getInstance();
 
        if (p1 != p2)
 
        {
 
              cout << "不是同一个对象" << endl;
 
        }
 
        else
 
        {
 
              cout << "是同一个对象" << endl;
 
        }
 
        p1->printT();
 
        p2->printT();
 
        Singelton2::FreeInstance();
 
        Singelton2::FreeInstance();
 
 
 
       system("pause");
 
}

懒汉单例和饿汉单例多线程场景分析

1."懒汉"模式虽然有优点，但是每次调用GetInstance()静态方法时，必须判断NULL == m_instance，使程序相对开销增大；

2.多线程中会导致多个实例的产生，从而导致运行代码不正确以及内存的泄露；

3.未提供释放资源的函数，存在内存泄漏问题。

由于C++中构造函数并不是线程安全的。C++中的构造函数简单来说分两步：

第一步：内存分配；

第二步：初始化成员变量；

由于多线程的关系，可能当我们在分配内存好了以后，还没来得急初始化成员变量，就进行线程切换，另外一个线程拿到所有权后，由于内存已经分配了，但是变量初始化还没进行，因此获取成员变量的相关值会发生不一致现象。

优化后的单例模式

  由于多线程资源竞争问题，程序的并发执行往往带来与时间有关的错误，甚至引发灾难性的后果。这需要引入同步机制。使用多进程与多线程时，有时需要协同两种或多种动作，此过程就称同步（Synchronization）。引入同步机制的第一个原因是为了控制线程之间的资源同步访问，因为多个线程在共享资源时如果发生访问冲突通常会带来不正确的后果。例如，一个线程正在更新一个结构，同时另一个线程正试图读取同一个结构。结果，我们将无法得知所读取的数据是新的还是旧的，或者是二者的混合。第二个原因是有时要求确保线程之间的动作以指定的次序发生，如一个线程需要等待由另外一个线程所引起的事件。为了在多线程程序中解决同步问题，Windows提供了四种主要的同步对象，每种对象相对于线程有两种状态——信号状态（signal state）和非信号状态（nonsignal state）。当相关联的同步对象处于信号状态时，线程可以执行（访问共享资源），反之必须等待。 这四种同步对象是：

（1）事件对象（Event）。事件对象作为标志在线程间传递信号。一个或多个线程可等待一个事件对象，当指定的事件发生时，事件对象通知等待线程可以开始执行。它有两种类型：自动重置（auto-reset）事件和手动重置（manual-reset）事件。

（2）临界区（Critical Section）。临界区对象通过提供一个进程内所有线程必须共享的对象来控制线程。只有拥有那个对象的线程可以访问保护资源。在另一个线程可以访问该资源之前，前一个线程必须释放临界区对象，以便新的线程可以索取对象的访问权。

（3）互斥量（Mutex Semaphore）。互斥量的工作方式非常类似于临界区，只是互斥量不仅保护一个进程内为多个线程使用的共享资源，而且还可以保护系统中两个或多个进程之间的的共享资源。

（4）信号量（Semaphore）。信号量可以允许一个或有限个线程访问共享资源。它是通过计数器来实现的，初始化时赋予计数器以可用资源数，当将信号量提供给一个线程时，计数器的值减1，当一个线程释放它时，计数器值加1。当计数器值小于等于0时，相应线程必须等待。信号量是Windows98同步系统的核心。从本质上讲，互斥量是信号量的一种特殊形式。

#include "iostream"
 
#include <QMutex>
 
using namespace std;
 
 
 
QMutex *m_hCriticalSection; /* 临界区 */
 
 
 
class Singleton
 
{
 
private:
 
        Singleton(){};
 
        Singleton(const Singleton &);
 
        Singleton& operator = (const Singleton &);
 
 
 
public:
 
        static Singleton *Instantialize()
 
        {
 
                if(pInstance == NULL) //double check
 
                {
 
                        m_hCriticalSection.lock(); //只有当pInstance等于null时，才开始使用加锁机制 二次检查
 
 
 
                        if(pInstance == NULL)
 
                        {
 
                              pInstance = new Singleton();
 
                        }
 
                m_hCriticalSection.unlock();
 
                }
 
                return pInstance;
 
        }
 
        static Singleton *pInstance;
 
};
 
Singleton* Singleton::pInstance = 0;