在centos上做网站/谷歌推广方案

1. 单例模式的作用

    保证多个进程内，（即使多线程访问）该对象的实例只有一个，而且只会被创建一次。

2. 单例模式什么时候用？

     该对象的构造函数非常耗时，实例化一次该对象，需要非常长的时间，这样如果每次都去创建，会消耗很多资源。

3. 单例模式的代价

    private static Singleton _Singleton = null;  该静态对象不会被回收，会常驻内存。

4. 特别注意

   单例只保证了实例的唯一，并不能保证实例中的方法或变量也唯一，所以单例中的方法或变量，在多线程面前，仍然可能是不安全的。

5. 单例模式的三种写法

   双if+Lock（懒汉模式）、静态构造函数（饿汉模式）、静态变量（饿汉模式）。

   (1). 双if+Lock

   下面重点介绍“双if+Lock”由单线程→多线程的演变过程。

 public class SOne
    {
        /// <summary>
        /// 模拟耗时的构造函数
        /// </summary>
        public SOne()
        {
            long result = 0;
            for (int i = 0; i < 1000000; i++)
            {
                result += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造...", this.GetType().Name);
        }

        private static SOne _Sone = null;
        private static object SoneLock = new object();

        /// <summary>
        /// 单线程内单例模式
        /// </summary>
        /// <returns></returns>
        public static SOne CreateIntance1()
        {
            //我们发现：在多线程中，实例创建了不止一次，原因是多个线程同时进入了
            if (_Sone == null)
            {
                _Sone = new SOne();
            }
            return _Sone;
        }
        /// <summary>
        /// 多线程的单例模式（安全+但是费时，费在锁上了）
        /// </summary>
        /// <returns></returns>
        public static SOne CreateIntance2()
        {
            //给下面的语句整体加上锁，即使多线程，也需要一个一个的进入锁中进行判断，不存在同时进入创建实例内部的情况了。
            //缺点：同时带来一个问题，所有的线程必须等着前面一个锁完成后，方可进入，即使实例已经创建完了，也需要等前面的锁完成，这样多个线程耗时就耗在等锁上了
            lock (SoneLock)
            {
                Console.WriteLine("我进入锁了，后面的要等我一下哦");
                Thread.Sleep(1000); //模拟锁操作耗时
                if (_Sone == null)
                {
                    _Sone = new SOne();
                }
            }
            return _Sone;
        }

        /// <summary>
        /// 多线程的单例模式（安全且不耗时）
        /// </summary>
        /// <returns></returns>
        public static SOne CreateIntance3()
        {
            //外层再加一层if，在进锁前就可以判断了，如果前面已经有实例创建好了，那么以后的就不需要等锁了，但是也可能存在多线程同时进入第一个if，那么同时进入的也要等一下哦。
            if (_Sone==null)
            {
                lock (SoneLock)
                {
                    Console.WriteLine("我进入锁了，后面的要等我一下哦");
                    //Thread.Sleep(1000); //模拟锁操作耗时
                    if (_Sone == null)
                    {
                        _Sone = new SOne();
                    }
                }
            }      
            return _Sone;
        }
    }

　　 (2). 静态构造函数

   public class STwo
    {
        /// <summary>
        /// 模拟耗时的构造函数
        /// </summary>
        private STwo()
        {
            long result = 0;
            for (int i = 0; i < 1000000; i++)
            {
                result += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造...", this.GetType().Name);
        }

        private static STwo _STwo = null;
        /// <summary>
        /// 静态的构造函数：只能有一个，且是无参数的
        /// 由CLR保证，只有在程序第一次使用该类之前被调用，而且只能调用一次
        /// </summary>
        static STwo()
        {
            _STwo = new STwo();
        }

        public static STwo CreateIntance()
        {
            return _STwo;
        }
    }

　　 (3). 静态变量

 public  class SThird
    {
        /// <summary>
        /// 模拟耗时的构造函数
        /// </summary>
        private SThird()
        {
            long result = 0;
            for (int i = 0; i < 1000000; i++)
            {
                result += i;
            }
            Thread.Sleep(1000);
            Console.WriteLine("{0}被构造...", this.GetType().Name);
        }
        /// <summary>
        /// 静态变量：由CLR保证，在程序第一次使用该类之前被调用，而且只调用一次
        /// </summary>
        private static SThird _SThird = new SThird();

        public static SThird CreateIntance()
        {
            return _SThird;
        }
    }