【23种设计模式】创建型模式 > 单例模式

对于一个软件系统的某些类而言，我们无须创建多个实例。比如Windows的任务管理器，只可能同时有一个打开。单例模式可以确保类对象的唯一性，并提供这个唯一对象的唯一访问点（getInstance()）。



在多线程环境下，需要防止getInstance()多次执行，可能会创建多个实例，违背单例模式的初衷。课本上的单例模式实现（线程不安全的懒汉实现）没有考虑多线程环境，是线程不安全的，考虑两个线程同时首次调用instance方法且同时检测到p是NULL值，则两个线程会同时构造一个实例给p，这是严重的错误。要解决这个问题，需要使用加锁的懒汉方式，或者使用饿汉方式。

单利模式有懒汉和饿汉两种实现方法：

懒汉：故名思义，不到万不得已就不会去实例化类（即在getinstace()里实例化），也就是说在第一次用到类实例的时候才会去实例化，所以上边的经典方法被归为懒汉实现；
饿汉：饿了肯定要饥不择食。所以在单例类定义的时候就进行实例化
特点与选择：
由于要进行线程同步，所以在访问量比较大，或者可能访问的线程比较多时，采用饿汉实现，可以实现更好的性能。这是以空间换时间。
在访问量较小时，采用懒汉实现。这是以时间换空间。

一、懒汉实现

1. 线程不安全的懒汉实现（课本级错误）

没有考虑多线程环境。
C++ 

#include <iostream>
using namespace std;

class MyClass
{
public:
static MyClass* getInstance() { return _myinstance == NULL ? (_myinstance = new MyClass()) : _myinstance; };
protected: // or private
MyClass() {};
private:
static MyClass* _myinstance;
};

MyClass* MyClass::_myinstance = 0;

int main()
{
MyClass* instance = MyClass::getInstance();
}

C#

using System;
class Program
{
class MyClass
{
private static MyClass myinstance = null;
private MyClass() { }
public static MyClass GetInstance()
{
if (myinstance != null)
return myinstance;
myinstance = new MyClass();
return myinstance;
}
}

public static void Main()
{
MyClass instance = MyClass.GetInstance();
}

}

2. 线程安全的懒汉实现

这种实现能在多线程的环境下正常工作，但是效率很低，因为大部分情况下都不需要同步，因为只在初始化的时候（_myinstance = new MyClass()）会由多线程引发问题，而当初始化结束时，多线程问题不复存在。而下面的实现使得每次调用 getInstance() 的时候都需要排队，等待释放临界区。为了避免这种情况应该使用实现3.双重检查锁定。
C++

#include <iostream>
using namespace std;

class MyClass
{
public:
static MyClass* getInstance()
{
Lock(); // 加锁，借用其他类库实现，如boost.
// 临界区
if (_myinstance == nullptr)
{
_myinstance = new MyClass();
}
Unlock(); //
return _myinstance;
};

protected: // or private
MyClass() {};
private:
static MyClass* _myinstance;
};

MyClass* MyClass::_myinstance = nullptr;

int main()
{
MyClass* instance = MyClass::getInstance();
}

C#

using System;
class Program
{
class LazySingleton
{
private static LazySingleton instance = null;
//程序运行时创建一个静态只读的辅助对象
private static readonly object syncRoot = new object();

private LazySingleton() { }

public static LazySingleton GetInstance()
{
//加锁的程序在某一时刻只允许一个线程访问
lock (syncRoot)
{
if (instance == null)
{
instance = new LazySingleton();  //创建单例实例
}
}
return instance;
}
}

public static void Main()
{
LazySingleton instance = LazySingleton.GetInstance();
}

}

3. 双重检查锁定

相对于2. 的懒汉实现，双重检查锁定把临界区放在第一次判空内部，这样只在初始化的时候，才会进入临界区，其余情况和单线程一样。第二次判空是为了防止在临界区排队的线程再次初始化单例。
C++

#include <iostream>
using namespace std;

class MyClass
{
public:
static MyClass* getInstance()
{
if (_myinstance == nullptr) // 第一次判断
{
Lock(); // 加锁
if (_myinstance == nullptr) // 第二次判断
{
_myinstance = new MyClass();
}
Unlock(); //
}
return _myinstance;
};

protected: // or private
MyClass() {};
private:
static MyClass* _myinstance;
};

MyClass* MyClass::_myinstance = nullptr;

int main()
{
MyClass* instance = MyClass::getInstance();
}

C# 

using System;
class Program
{
class LazySingleton
{
private static LazySingleton instance = null;
//程序运行时创建一个静态只读的辅助对象
private static readonly object syncRoot = new object();

private LazySingleton() { }

public static LazySingleton GetInstance()
{
//第一重判断，先判断实例是否存在，不存在再加锁处理
if (instance == null)
{
//加锁的程序在某一时刻只允许一个线程访问
lock (syncRoot)
{
//第二重判断
if (instance == null)
{
instance = new LazySingleton();  //创建单例实例
}
}
}
return instance;
}
}

public static void Main()
{
LazySingleton instance = LazySingleton.GetInstance();
}

}

二、饿汉实现

饿汉式实现是线程安全的, 单例类被加载时会将自己实例化，之后调用getInstance的时候，实例myinstance肯定不会为空，也就是说，类只会被实例化一次。
C++

#include <iostream>
using namespace std;

class MyClass
{
public:
static MyClass* getInstance()
{
return _myinstance;
}
private:
MyClass() {};
static MyClass* _myinstance;
};

MyClass* MyClass::_myinstance = new MyClass();

int main()
{
MyClass* instance = MyClass::getInstance();
}

C# 

using System;
class Program
{
class MyClass
{
private static MyClass myinstance = new MyClass();
private MyClass() { }
public static MyClass GetInstance()
{
return myinstance;
}
}

public static void Main()
{
MyClass instance = MyClass.GetInstance();
}

}

三、饿汉式单例类与懒汉式单例类比较

       饿汉式单例类在类被加载时就将自己实例化，它的优点在于无须考虑多个线程同时访问的问题，可以确保实例的唯一性；从调用速度和反应时间角度来讲，由于单例对象一开始就得以创建，因此要优于懒汉式单例。但是无论系统在运行时是否需要使用该单例对象，由于在类加载时该对象就需要创建，因此从资源利用效率角度来讲，饿汉式单例不及懒汉式单例，而且在系统加载时由于需要创建饿汉式单例对象，加载时间可能会比较长。

      懒汉式单例类在第一次使用时创建，无须一直占用系统资源，实现了延迟加载，但是必须处理好多个线程同时访问的问题，特别是当单例类作为资源控制器，在实例化时必然涉及资源初始化，而资源初始化很有可能耗费大量时间，这意味着出现多线程同时首次引用此类的机率变得较大，需要通过双重检查锁定等机制进行控制，这将导致系统性能受到一定影响。