设计模式之单例模式

设计模式之单例模式

单例模式

单例模式(Singleton Mode)

确保某一个类只有一个实例， 并且能自动实例化向整个系统提供这个实例，这样的类称为单例类。

• 单例模式的三个要点：
  1. 在单例类的内部实现中 只生成一个实例，同时提供一个静态的GetInstance() 方法，使外部可以访问该实例
  2. 为了防止外部进行实例化，将构造函数设置为private
  3. 在单例类内部定义一个Singleton类型的静态对象，作为外部共享的唯一实例。
• 应用：任务管理器（只能开一个）

懒汉单例模式

加载类时，便初始化静态变量Instance，创建单例类的唯一实例，可确保实例的唯一性。缺点是，不管使不使用该实例，都会创建该实例，有时候会造成内存资源的浪费。

public class EagerSingleton{
        private static readonly EagerSingleton Instance = new EagerSingleton();

        private EagerSingleton(){
            ;
        }

        public static void Test(){
             // 向外部提供的静态方法
        }

        public static EagerSingleton GetInstance(){
            return Instance;
        }
    }

懒汉单例模式

使用延迟加载(Lazy Load)技术，当需要实例的时候再加载实例，可以提高内存空间的利用率。但如果遇到多线程同时调用GetInstance() 方法时，保证不了单例对象的唯一性。

public class LazySingleton{
        private static LazySingleton _instance;
        private LazySingleton(){

        }
        public static void Test(){
            // 向外部提供的静态方法
        }
        public static LazySingleton GetInstance(){
            if (_instance == null)
                _instance = new LazySingleton();
            return _instance;
        }
    }

• 改进一：使用Lock机制保证单例对象的唯一性，但每次调用GetInstance()都进行线程锁定判断，会降低系统的性能。

public class LazySingleton{
        private static LazySingleton _instance;
        private static readonly object SynRoot = new object();
        private LazySingleton(){

        }
        public static void Test(){
            // 向外部提供的静态方法
        }
        public static LazySingleton GetInstance(){
            lock (SynRoot){ // Lock机制
                if (_instance == null)
                    _instance = new LazySingleton();    
            }
            return _instance;
        }
    }

• 改进二：使用双重检查锁定(Double Check Locking)。保证单例对象的唯一性，较改进一提高了系统性能，但仍然因为Lock机制降低了系统性能。

public class LazySingleton{
        private static LazySingleton _instance;
        private static readonly object SynRoot = new object();
        private LazySingleton(){

        }
        public static void Test(){
            // 向外部提供的静态方法
        }
        public static LazySingleton GetInstance(){
            if (_instance == null){
                lock (SynRoot){ // Lock机制
                    if (_instance == null)
                        _instance = new LazySingleton();    
                }
            }            
            return _instance;
        }
    }

饿汉和懒汉的结合（静态内部类）

饿汉单例模式可能会造成内存资源的浪费，懒汉单例模式会降低系统的性能。使用Initialization on Demand Holder(loDH)技术可以集两家之所长，即保证单例对象的唯一性，又不影响系统性能。

public class Singleton{
        private static class HolderClass{
            public static readonly Singleton Instance = new Singleton();
        }

        private Singleton(){

        }

        public static void Test(){
            // 向外部提供的静态方法
        }
        public static Singleton GetInstance(){
            return HolderClass.Instance;
        }
}

在类中嵌套一个静态类，通过这个静态类来创建单例对象。当调用GetInstance()方法时，会加载静态类HolderClass，进行单例对象的创建，此过程由.NET保证其线程安全。

这样的方法保证了单例对象的唯一性，也实现了延迟加载，且没有使用锁机制，对系统的性能没有造成影响。

• 运行实例：

using System;

namespace DesignMode
{
    class Program
    {
        static void Main(string[] args)
        {
            Singleton s1 = Singleton.GetInstance();
            Singleton s2 = Singleton.GetInstance();
            if (object.ReferenceEquals(s1, s2))
                Console.WriteLine("两个对象是相同的实例");
        }
    }    
}

其结果为：