【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();  
    }

}

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

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

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