【设计模式】-单例模式

/// <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);
        }
    }

    class Program
    {
        /// <summary>
        /// 单例模式就是保证在整个应用程序的生命周期中，在任何时刻，被指定的类只有一个实例，并为客户程序提供一个获取该实例的全局访问点
        /// 比如说 回收站
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            Singleton A = Singleton.GetInstance();
            A.Age = 1;
            A.GetShow();
            A = Singleton.GetInstance();
            A.GetShow();         
        }
           
    }

/// <summary>  
    /// 二、多线程下的单例模式  
    /// 1、Lazy模式  
    /// </summary>  
    public class Singleton2
    {
        //1.私有变量
        private static Singleton2 instance2;
        //2.锁
        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);
        }

    }  


    class Program
    {
        /// <summary>
        /// 单例模式就是保证在整个应用程序的生命周期中，在任何时刻，被指定的类只有一个实例，并为客户程序提供一个获取该实例的全局访问点
        /// 比如说 回收站
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            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();  
        }
           
    }

namespace Singleton 
{ 
    public sealed class Singleton 
    { 
        private static readonly Singleton singleton = new Singleton();

        private Singleton() 
        { 
        }

        public static Singleton GetInstance() 
        { 
            return singleton; 
        } 
    }