C# 单例模式

单例模式解读:

在应用程序中,保证类型只有一个实例,只允许实例化一次;

步骤:

首先构造函数私有化,以保证对象不会被它人实例化;

提供一个公开的静态方法供他人获取对象的实例;

防止并发情况破坏单例,在创建对象时加锁

第一种方法:

    /// <summary>
    /// 懒汉式单例写法:只有在调用CreateInstance方法后才会实例化Single对象
    /// </summary>
    public sealed class Single
    {
        private Single()
        {
            long result = 0;
            for (int i = 0; i < 10000; i++)
            {
                result += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine($"{this.GetType().Name}已被构造");
        }
        private static Single single = null;//静态字段在内存中是唯一的,不会被GC
        private static readonly object SingLock = new object();

        public static Single CreateInstance()
        {
            //先判断对象是否为null,不为null就不执行里面的代码,直接返回对象
            if (single == null)
            {
                //加锁:任意时刻只有一个线程能进去,解决并发问题
                lock (SingLock)
                {
                    if (single == null)//这个判断不能去掉,保证只初始化一次
                    {
                        //方法第一次进来会new一个实例,只会被构造一次
                        single = new Single();
                    }
                }
            }
            return single;
        }
        public void Message()
        {
            Console.WriteLine($"{typeof(Single)}");
        }
    }
static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Task.Run(() =>//会抛十个线程
                {
                    Single single = Single.CreateInstance();
                    single.Message();
                });
            }
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }

 

第二种:

    /// <summary>
    /// 饿汉式单例写法:在调用类中的任意成员时都会先实例化这个类
    /// </summary>
    public class SingleSecond
    {
        private SingleSecond()
        {
            long result = 0;
            for (int i = 0; i < 10000; i++)
            {
                result += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine($"{this.GetType().Name}以被构造");
        }
        private static SingleSecond single = null;//静态字段在内存中是唯一的,不会被GC

        /// <summary>
        /// 静态构造函数:由CLR保证,在第一次使用到这个类型之前,自动调用且只调用一次
        /// </summary>
        static SingleSecond()
        {
            single = new SingleSecond();
        }
        public static SingleSecond CreateInstance()
        {
            return single;
        }
        public void Message()
        {
            Console.WriteLine($"{typeof(SingleSecond)}");
        }
    }
static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Task.Run(() =>//会抛十个线程
                {
                    SingleSecond single = SingleSecond.CreateInstance();
                    single.Message();
                });
            }
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }

 

第三种:

    /// <summary>
    /// 饿汉式单例写法:在调用类中的任意成员时都会先实例化这个类
    /// </summary>
    public class SingeThird
    {
        private SingeThird()
        {
            long result = 0;
            for (int i = 0; i < 10000; i++)
            {
                result += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine($"{this.GetType().Name}以被构造");
        }
        /// <summary>
        /// 静态字段:由CLR保障,在第一次使用这个类型之前,会自动初始化且初始化一次
        /// </summary>
        private static SingeThird single = new SingeThird();
        public static SingeThird CreateInstance()
        {
            return single;
        }
        public void Message()
        {
            Console.WriteLine($"{typeof(SingleSecond)}");
        }
    }
 static void Main(string[] args)
        {
            for (int i = 0; i < 10; i++)
            {
                Task.Run(() =>//会抛十个线程
                {
                    SingeThird single = SingeThird.CreateInstance();
                    single.Message();
                });
            }
            Console.WriteLine("Hello World!");
            Console.ReadKey();
        }

单例模式的特点:

同一个实例不能解决多线程并发问题,会存在线程冲突;

全局只有一个单例,对对象里的成员进行修改时,在任何地方调用都是上次修改的值,而不是初始值;

The End!

 

上一篇:136. Single Number


下一篇:深度学习论文:Learning Spatial Fusion for Single-Shot Object Detection及其PyTorch实现