单例模式

    /// <summary>
    /// 单例类：一个构造对象很耗时耗资源类型
    /// 
    /// 懒汉式
    /// </summary>
    public class Singleton
    {
        /// <summary>
        /// 构造函数耗时耗资源
        /// </summary>
        private Singleton()
        {
            long lResult = 0;
            for (int i = 0; i < 10000000; i++)
            {
                lResult += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造一次", this.GetType().Name);
        }

        private static volatile Singleton _Singleton = null;
        private static object Singleton_Lock = new object();

        public static Singleton CreateInstance()
        {
            if (_Singleton == null)//不为空，才去等待锁
            {
                lock (Singleton_Lock)//没有多线程  只有线程进程
                {
                    //Thread.Sleep(500);
                    Console.WriteLine("等待锁之后，释放锁");
                    if (_Singleton == null)//保证锁里面不能重复创建
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }

        //既然是单例，大家用的是同一个对象，用的是同一个方法，那还会并发吗  还有线程安全问题吗？
        //当然有，，单例不能解决线程冲突的  解决：加锁

        public int iTotal = 0;
        public void Show()
        {
            this.iTotal++;//非线程安全的
            //Console.WriteLine("这里是{0}.Show", this.GetType().Name);
        }

    }


    /// <summary>
    /// 创建型设计模式：关注类型的实例化
    /// 结构型设计模式：关注类与类之间的关系
    /// 行为型设计模式：关注对象和行为的分离
    /// 
    /// 单例模式
    /// 
    /// 饿汉式 ：第一时间创建实例
    /// 懒汉式 ：需要才创建实例
    /// 
    /// 单例模式会长期持有一个对象，不会释放
    /// 普通实例使用完后释放
    /// 
    /// 单例可以只构造一次，提升性能(如果构造函数耗性能)
    /// 
    /// 单例就是保证类型只有一个实例：计数器/数据库连接池
    /// 
    /// 
    /// </summary>
    class Program
    {
        /// <summary>
        /// 静态字段在程序进程只有一个
        /// 泛型类是例外
        /// </summary>
        //public static Singleton singleton = new Singleton();
        static void Main(string[] args)
        {
            try
            {
                //Singleton singleton = new Singleton();
                //对象的重用 

                TaskFactory taskFactory = new TaskFactory();
                List<Task> taskList = new List<Task>();
                for (int i = 0; i < 10000; i++)
                {
                    taskList.Add(taskFactory.StartNew(() =>
                    {
                        Singleton singleton = Singleton.CreateInstance();// new Singleton();
                        singleton.Show();
                    }));
                }

                Task.WaitAll(taskList.ToArray());
                Console.WriteLine("第一轮全部完成");
                //0   1       10000   小于10000
                Console.WriteLine(Singleton.CreateInstance().iTotal);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }