23种设计模式-01-单例模式

public sealed class SingletonFirst
    {
        private SingletonFirst() { }

        private static SingletonFirst _Instance = null;

        public static SingletonFirst Instance
        {
            get
            {
                if (_Instance == null)
                {
                    _Instance = new SingletonFirst();
                    Console.WriteLine(nameof(SingletonFirst) + "实例化了");
                }
                return _Instance;
            }
        }
    }

public sealed class SingletonSecond
    {
        private SingletonSecond() { }

        private static SingletonSecond _Instance = null;

        private static readonly object _Locker = new object();

        public static SingletonSecond Instance
        {
            get
            {
                //这样可以避免并发多次实例化，
                //但是会影响性能，每一次进来判断都是排队，性能缺失很大
                CoreService.RunLock(_Locker, () =>
                {
                    if (_Instance == null)
                    {
                        _Instance = new SingletonSecond();
                        Console.WriteLine(nameof(SingletonSecond) + "实例化了");
                    }
                });
                return _Instance;
            }
        }
    }

public sealed class SingletonThird
    {
        private SingletonThird() { }

        private static SingletonThird _Instance = null;

        private static readonly object _Locker = new object();

        public static SingletonThird Instance
        {
            get
            {
                //通过两次判断，即不会特别影响性能，还可以达到单例的效果
                //可以多线程进行判断操作，但是如果未实例化，再次进去实例化的时候，就要进行排队判断了
                if (_Instance == null)
                {
                    CoreService.RunLock(_Locker, () =>
                    {
                        if (_Instance == null)
                        {
                            _Instance = new SingletonThird();
                            Console.WriteLine(nameof(SingletonThird) + "实例化了");
                        }
                    });
                }
                return _Instance;
            }
        }
    }

public sealed class SingletonStatic
    {
        private SingletonStatic() { }

        private static SingletonStatic _Instance = null;

        //利用静态构造函数的特性：在第一次使用该类时会有且仅有调用一次该静态构造函数，这样可以达到单例的效果
        static SingletonStatic()
        {
            _Instance = new SingletonStatic();
            Console.WriteLine(nameof(SingletonStatic) + "实例化了");
        }

        public static SingletonStatic Instance
        {
            get
            {
                return _Instance;
            }
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            try
            {
                //TestFirst();
                //TestSecond();
                //TestThird();
                TestStatic();
            }
            catch (Exception e)
            {
                Console.WriteLine("发生异常：" + e.Message);
            }
            Console.WriteLine("End");
            Console.ReadKey();
        }

        private static void TestFirst()
        {
            for (int i = 1; i <= 100; i++)
            {
                Task.Run(() =>
                {
                    var instance = SingletonFirst.Instance;
                });
            }
        }

        private static void TestSecond()
        {
            for (int i = 1; i <= 100; i++)
            {
                Task.Run(() =>
                {
                    var instance = SingletonSecond.Instance;
                });
            }
        }

        private static void TestThird()
        {
            for (int i = 1; i <= 100; i++)
            {
                Task.Run(() =>
                {
                    var instance = SingletonThird.Instance;
                });
            }
        }

        private static void TestStatic()
        {
            for (int i = 1; i <= 100; i++)
            {
                Task.Run(() =>
                {
                    var instance = SingletonStatic.Instance;
                });
            }
        }
    }