单例模式（对象创建型）c++

单例模式是：保证一个类仅有一个实例，并提供该一个访问它的全局访问点。

通常可以让一个全局变量是的一个对象被访问，但它不能防止你实例化多个对象。一个好的方法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建（将构造方法定义为私有的或保护的），并且提供一个访问该实例的方法（static方法）。这个实例是类的static变量，对于这个类只有一份。取得实例的方法是静态的，因为构造函数是私有的，所以只能通过类对象直接获得，所以方法也只能定义为静态的。不然无法获得实例。

单例模式最基本的分为两种：饿汉式、懒汉式

饿汉模式是：自己被加载时就将自己实例化。即定义时直接定义为类的一个对象。

另外因为定义的静态变量pInstance是一个指针，可以将一个指向Singleton子类的指针赋给这个变量。

这种是懒汉式单例类：即第一次被引用时，才将自己实例化。即pInstance被初始化为NULL, 而实际初始化是在函数中。懒汉式单例模式存在的问题是，当多线程环境下会出现同步问题，需要控制。

以下为饿汉懒汉实现代码：

////单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点
#include <iostream>
using namespace std;

//这种是饿汉式单例模式，即在类被构造出来后就将实例构造出来，
//会提前占用系统资源
class HungrySingleton
{
public:
//这种是饿汉式单例模式，即在类被构造出来后就将实例构造出来，
//会提前占用系统资源
static HungrySingleton *getInstance()
{
return instance;
}
private:
HungrySingleton()
{}
static HungrySingleton* instance;
};
//这里是关键，直接初始化为类的对象，因为是类内数据，所以可以调用构造函数
HungrySingleton* HungrySingleton::instance = new HungrySingleton;

//这种是懒汉式单例模式，即在使用时才将实例构造出来，
//但这个会出现线程同步问题。
class LazySingleton
{
public:
//函数必须是静态的，否则无法访问
static LazySingleton *getInstance()
{
//如果两个线程同时进入getinstance,同时执行，则有两个实例被构造出来
if (instance == NULL)
instance = new LazySingleton();
return instance;
}
private:
//构造函数私有的，不能再外部定义实例
LazySingleton()
{}
static LazySingleton* instance;
};
//初始化为0
LazySingleton* LazySingleton::instance = 0;

int main()
{
HungrySingleton *h1 = HungrySingleton::getInstance();
HungrySingleton *h2 = HungrySingleton::getInstance();

cout << "饿汉式单例模式运行结果:" << endl;
if (h1 == h2)
cout << "是同一个对象" << endl;

LazySingleton *h3 = LazySingleton::getInstance();
LazySingleton *h4 = LazySingleton::getInstance();

cout << "懒汉式单例模式运行结果:" << endl;
if (h3 == h4)
cout << "是同一个对象" << endl;
return 0;
}

为了解决懒汉式的多线程同步问题，加入锁，使用了互斥量，下面是实现代码：

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

//解决懒汉式单例模式的多线程同步问题，即在new对象前加上锁，锁的实现在
//linux下采用mutex就够了，因为与顺序无关，只要保证一个时间只有一个线程就行了

class ThreadLazySingleton
{
public:
static ThreadLazySingleton* getInstance(pthread_mutex_t mutex)
{
if (instance == NULL)
{
pthread_mutex_lock(&mutex);
//双重检查，因为如果有两个线程同时通过第一个条件判断，进入到
//内部条件，然后一个线程先申请到互斥量，之后如果为NULL，创建，
//但它退出后，已经分配了一个，所以必须再次重新判断一次是否为
//NULL，否则会再次分配一个对象。
if (instance == NULL)
{
instance = new ThreadLazySingleton;
cout << "getInstance():" << instance << endl;
}
pthread_mutex_unlock(&mutex);
return instance;
}
}
private:
ThreadLazySingleton() {}
static ThreadLazySingleton *instance;
};

ThreadLazySingleton* ThreadLazySingleton::instance = NULL;

void *th_fn1(void *args)
{
cout << "线程" << pthread_self() << "开始运行" << endl;
pthread_mutex_t *mutex = (pthread_mutex_t*)args;
ThreadLazySingleton *p = ThreadLazySingleton::getInstance(*mutex);
cout << p << endl;
pthread_exit((void*)p);
}

int main()
{
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL); //初始化互斥量

int err;
pthread_t tid1, tid2;
ThreadLazySingleton* p1;
ThreadLazySingleton* p2;
err = pthread_create(&tid1, NULL, th_fn1, &mutex);
if (err != 0)
cout << "创建线程" << tid1 << "错误！" << endl;
err = pthread_create(&tid2, NULL, th_fn1, &mutex);
if (err != 0)
cout << "创建线程" << tid2 << "错误！" << endl;
pthread_join(tid1, (void**)&p1);
pthread_join(tid2, (void**)&p2);
//pthread_mutex_destory(&mutex);

if (p1 == p2)
cout << "同一个对象，同步正确" << endl;
cout << p1 <<" " << p2 << endl;
return 0;
}

以上是目前所学到的单例模式的内容。以后会不定时再补充～～