【C#设计模式-单例模式】

不念不忘少年蓝@ 2022-08-21 07:44 164阅读 0赞

**单例模式就是保证在整个应用程序的生命周期中，在任何时刻，被指定的类只有一个实例，并为客户程序提供一个获取该实例的全局访问点**

**![20160512120044907][]**

**一：经典模式：**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication3
    {
        /// <summary>
        /// 一、经典模式：
        /// </summary>
        public class Singleton
        {
            /// <summary>
            /// Singleton的构造函数必须是私有的，以保证客户程序不会通过new()操作产生一个实例，达到实现单例的目的；
            /// </summary>
            private Singleton(){ }
    
            /// <summary>
            /// 私有的静态全局变量instance来保存该类的唯一实例；
            /// </summary>
            private static Singleton instance;
    
            /// <summary>
            /// 提供一个全局函数访问获得该实例，并且在该函数提供控制实例数量的功能，
            /// 即通过if语句判断instance是否已被实例化，
            /// 如果没有则可以同new（）创建一个实例；
            /// 否则，直接向客户返回一个实例
            /// </summary>
            /// <returns></returns>
            public static Singleton GetInstance()
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
                return instance;
            }
    
            /// <summary>
            /// 测试属性
            /// </summary>
            public int Age { get; set; }
    
            public void GetShow()
            {
                this.Age = this.Age + 1;
                Console.WriteLine("我是一个单例对象：Age=" + Age);
            }
        }
    }

1）该Singleton的构造函数必须是私有的，以保证客户程序不会通过new（）操作产生一个实例，达到实现单例的目的；

2）因为静态变量的生命周期跟整个应用程序的生命周期是一样的，所以可以定义一个私有的静态全局变量instance来保存该类的唯一实例；

3）必须提供一个全局函数访问获得该实例，并且在该函数提供控制实例数量的功能，即通过if语句判断instance是否已被实例化，如果没有则可以同new（）创建一个实例；否则，直接向客户返回一个实例。

在这种经典模式下，没有考虑线程并发获取实例问题，即可能出现两个线程同时获取instance实例，且此时其为null时，就会出现两个线程分别创建了instance，违反了单例规则。因此，需对上面代码修改。

二.多线程下的单例模式:

**1、Lazy模式**

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication3
    {
        /// <summary>
        /// 二、多线程下的单例模式
    　　/// 1、Lazy模式
        /// </summary>
        public class Singleton2
        {
            private static Singleton2 instance2;
            private static object _lock = new object();
    
            private Singleton2()
            {
    
            }
    
            public static Singleton2 GetInstance(string thnum)
            {
                //外层的if语句块，这使得每个线程欲获取实例时不必每次都得加锁，
                //因为只有实例为空时（即需要创建一个实例），才需加锁创建，
                //若果已存在一个实例，就直接返回该实例，节省了性能开销
                if (instance2 == null)
                {
                    //Console.WriteLine("object is null" + thnum);
                    lock (_lock) 
                    {
                        //内层的if语句块，使用这个语句块时，先进行加锁操作，
                        //保证只有一个线程可以访问该语句块而保证只创建了一个实例
                        if (instance2 == null)
                        {
                            //Console.WriteLine("object not null" + thnum);
                            instance2 = new Singleton2();
                            instance2.Age = 0;
                        }
                    }
                }
                return instance2;
            }
    
            /// <summary>
            /// 测试属性
            /// </summary>
            public int Age { get; set; }
    
            public void GetShow(string thnum)
            {
                this.Age = this.Age + 1;
                Console.WriteLine("我是一个单利对象：Age=" + Age+" 线程："+thnum);
            }
    
        }
    }

**上述代码使用了双重锁方式较好地解决了多线程下的单例模式实现。**

**内层的if语句块，使用这个语句块时，先进行加锁操作，保证只有一个线程可以访问该语句块，进而保证只创建了一个实例。**

**外层的if语句块，这使得每个线程欲获取实例时不必每次都得加锁，因为只有实例为空时（即需要创建一个实例），才需加锁创建，若果已存在一个实例，就直接返回该实例，节省了性能开销。**

2.饿汉模式：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication3
    {
        /// <summary>
        /// 二、多线程下的单例模式
        /// 2、饿汉模式
    　　/// 这种模式的特点是自己主动实例。
        /// </summary>
        public class Singleton3
        {
            /// <summary>
            /// 主动实例
            /// </summary>
            private static readonly Singleton3 instance = new Singleton3();
    
            private Singleton3()
            {
    
            }
    
            public static Singleton3 GetInstance()
            {
                return instance;
            }
        }
    }

测试：

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    
    namespace ConsoleApplication3
    {
        class Program
        {
            static void Main(string[] args)
            {
    
                Console.WriteLine("一、经典模式：测试");
                //Singleton s = new Singleton(); Error 编译器检测出现错误
                Singleton s = Singleton.GetInstance();
                s.GetShow();
                Singleton s1 = Singleton.GetInstance();
                s1.GetShow();
                Singleton s12 = Singleton.GetInstance();
                s12.GetShow();
    
                Console.WriteLine("二、多线程下的单例模式>Lazy模式：测试");
                Thread thr1 = new Thread(x => {
                    Singleton2 s2 = Singleton2.GetInstance("thr1");
                    s2.GetShow("thr1");
                    s2.GetShow("thr1");
                });
                thr1.Start();
                Thread thr2 = new Thread(x => {
                    Singleton2 s22 = Singleton2.GetInstance("thr2");
                    s22.GetShow("thr2");
                });
                thr2.Start();
                Console.Read();
            }
        }
    }

![20160422184645107][]

[20160512120044907]: /images/20220724/a0945a53d9584ff08d50e5c1d431b9b2.png
[20160422184645107]: /images/20220724/51c534854e89485c94c025a06059e047.png