从头学习设计模式（一）——单例模式

【原】从头学习设计模式（一）——单例模式

 

一、引入

　　单例模式作为23种设计模式中的最基础的一种模式，在平时开发中应用也非常普遍。到底哪些类应该设计成单例的呢，我们来举个最通俗的例子。在一个父容器中单击某个菜单项打开一个子窗口，如果不使用单例又没有作菜单项的可用控制的话，每次单击菜单项都会打开一个新窗口。这不仅会浪费内存资源，在程序逻辑上也是不可以接受的。

二、最简单的单例

　　下面来看一个最简单的单例模式的构造形式

    public class Program
    {
        private static void Main(string[] args)
        {

            GetInstance();
            Console.ReadLine();
        }

        private void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
                Console.WriteLine("Create a singleton instance!");
            }
            return instance;
        }
    }

 

　　这里通过几个关键的地方以保证返回唯一的实例：

1. 私有的构造器，防止客户端用new关键字去创建实例对象
2. 静态的instance对象，保证全局唯一性
3. 对外的公共的静态实例方法，从类级别直接可调用此方法
4. 通过判断null值，决定是创建新实例还是直接返回。

 

三、并发下的单例

　　不过，以上标准的单例构造模式在多并发的情况下就有可能失效，请参考下面的这种情况。

 

        private static void Main(string[] args)
        {
            //开启10个线程来模拟多并发的情况
            for (int i = 0; i < 10; i++)
            {
                Thread thread = new Thread(new ThreadStart(GetInstance));
                thread.Start();
            }
            Console.ReadLine();
        }

        private static void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            //让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
            Thread.Sleep(10);
            if (instance == null)
            {
                instance = new Singleton();
                Console.WriteLine("Create a singleton instance!");
            }
            return instance;
        }
    }

 

　　以上的程序中开启了10个线程，来模拟多个用户同时访问getInstance方法。在getInstance方法里，开始先让线程睡一会，以模拟多个线程都已经进入了该方法。从运行的结果看上，基本上不能保证实例化唯一的实例了。

 

　　产生这种问题的原因就是，当一个线程进入getInstance 方法，通过了 instance==null 的条件，还没有来的及执行 instance = new Singleton() 时，另一个线程也通过了条件判断，这时就会 new Singleton() 多次了。

　　解决的办法就是加锁,只让一个线程进来，参考以下代码：

 

    public class Program
    {
        private static void Main(string[] args)
        {
            //开启100个线程来模拟多并发的情况
            for (int i = 0; i < 100; i++)
            {
                Thread thread = new Thread(new ThreadStart(GetInstance));
                thread.Start();
            }
            Console.ReadLine();
        }

        private static void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private static readonly object objForLock=new object();
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            //让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
            Thread.Sleep(10);
            //加一道锁只让一个线程进来
            lock (objForLock)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                    Console.WriteLine("Create a singleton instance!");
                }
            }
            return instance;
        }
    }

 

　　这样差不多可以达到我们的要求，只有一个实例对象存在可以保证了，但是这样会带来一点性能问题。如果每个线程进入getInstance方法后，都要lock一下以进行线程同步的话，每个线程到这里都要等待解锁后才能进入，但是如果 instance已经不是null了，那就应该直接返回而不是等待解锁，所以这里需要引入“双重锁”的单例构造方法，代码如下：

        private static void Main(string[] args)
        {
            //开启100个线程来模拟多并发的情况
            for (int i = 0; i < 100; i++)
            {
                Thread thread = new Thread(new ThreadStart(GetInstance));
                thread.Start();
            }
            Console.ReadLine();
        }

        private static void GetInstance()
        {
            Singleton objectSingleton = Singleton.getInstance();
        }
    }

    public class Singleton
    {
        private static Singleton instance = null;
        private static readonly object objForLock=new object();
        private Singleton()
        {
        }

        public static Singleton getInstance()
        {
            //让线程睡一会，来模拟有多个进程都已经在调用getInstance方法
            Thread.Sleep(10);
            //先判断是不是已经实例化过了，避免进入锁等待状态
            if(instance ==null)
            {
                //加一道锁只让一个线程进来
                lock (objForLock)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                        Console.WriteLine("Create a singleton instance!");
                    }
                }
            }

            return instance;
        }
    }

 

四、“懒汉式”单例与“饿汉式”单例的比较

　　所谓的“懒汉式”与“饿汉式”，就是实例对象的初始化时间不同：

　　1. 在需要实例化的时候才进行实例化，就是懒汉式。我们上面的这些例子都是懒汉式的。懒汉式有好处当然是节省资源啦，需要的时候才去构造，平时不用占用内存。不过，这会带来上面提到的在多并发下需要加锁限制访问的问题。

　　2.类加载时就直接进行实例化，就是饿汉式。例如下面的代码：

    private static Singleton instance = new Singleton();
    
    private Singleton() {
        
    }
    
    public static Singleton getInstance() {
        return instance;
    }

　　饿汉式单例是当类第一次被加载时就会将instance进行实例化，这样作的好处是不会带来多并发下的线程安全问题了，也不用考虑锁了。但反过来带来的就是性能问题了，因为不管你需不需要将这个实例对象创建出来，它都已经被创建出来常驻内存了。所以如果是一个工厂模式、缓存了很多实例、那么就得考虑效率问题，因为这个类一加载则把所有实例不管用不用一块创建。
　　这里只是对两种构造模式作了一个简单的对比，实际项目中要应用哪种模式还是要看具体需求而定。