单例模式 Singleton Pattern

单例模式的要点：

一是某个类只能有一个实例；

二是它必须自行创建这个实例；

三是它必须自行向整个系统提供这个实例。

 

从具体实现角度来说，就是以下三点：

一是单例模式的类只提供私有的构造函数；

二是类定义中含有一个该类的静态私有对象；

三是该类提供了一个静态的公有的函数用于创建或获取它本身的静态私有对象。

 

懒汉模式（被调用时创建 ，线程不安全）

/// <summary>
    /// lazy singleton pattern（ 线程不安全实例可能被创建多次 已优化）
    /// </summary>
    class Singleton
    {
        private static Singleton _instance=null;

        private static object _lock = new object();

        private Singleton()
        {
            Console.WriteLine("被创建");
        }

        public static Singleton GetInstance()
        {
            Console.WriteLine("加载中");

            if (_instance==null)//双重加锁  解决线程并发安全的问题
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        return _instance = new Singleton();
                    }
                }

            }
           
            return _instance;
        }

 调用

static void Main(string[] args)
        {
            HashSet<string> vs = new HashSet<string>();
            Console.WriteLine("lazy");
            TaskFactory taskFactory = new TaskFactory();
            List<Task> tasks = new List<Task>();
            Thread.Sleep(5000);
            for (int i = 0; i < 5; i++)
            {
                tasks.Add(taskFactory.StartNew(() =>
                {
                    Singleton temp = Singleton.GetInstance();
                    vs.Add(temp.ToString());
                }));

            }
            Thread.Sleep(5000);
            Console.WriteLine(vs.Count);
            Console.Read();
        }

优化前 实例被创建多次

 优化后

饿汉模式

 1     /// <summary>
    /// EagerPattern 先创建实例  线程安全 耗内存 效率变低
    /// </summary>
    class EagerSingleton
    {
        private readonly static EagerSingleton _instance = new EagerSingleton();
        private EagerSingleton()
        {
        }
        public EagerSingleton GetInstance()
        {
           return _instance;
        }
    }

在这种模式下，无需自己解决线程安全性问题，CLR会给我们解决。这个类被加载时，会自动实例化这个类。但是不管用不用，都会先实例化。