设计模式之单例模式

一、单例模式：保证一个类仅能产生一个实例。

二、单例模式的实现思路：类的实例化在类内部进行，并提供一个访问实例的入口，防止外部new实例。

三、单例模式的常规实现方式：

1、 代码如下：

namespace Singleton
{
    public class singletonOne
    {
        private singletonOne()//私有化构造函数的目的是为了防止外界进行实例化对象
        {
            Thread.Sleep(1000);//模拟耗时的实例化操作,常见的损耗有耗时、耗计算资源(ram,cpu等)、耗有限资源(数据库连接等)
            Console.WriteLine("线程id={0}的线程构造了{1}对象...",Thread.CurrentThread.ManagedThreadId,this.GetType().Name);
        }
        private static singletonOne _singleton = null;
        private static object lockobj = new object();//创建锁对象
        public static singletonOne CreateInstance()//私有化构造函数后，提供一个外界调用对象的入口
        {
            if (_singleton == null)
            {
                lock (lockobj)
                {
                    if(_singleton==null)
                    {
                        _singleton = new singletonOne();
                    }
                }
            }
            return _singleton;
        }
    }
}

 

2、代码如下：

namespace Singleton
{
    public class singletonTwo
    {
        private singletonTwo()//私有化构造函数的目的是为了防止外界进行实例化对象
        {
            Thread.Sleep(1000);//模拟耗时的实例化操作,常见的损耗有耗时、耗计算资源(ram,cpu等)、耗有限资源(数据库连接等)
            Console.WriteLine("线程id={0}的线程构造了{1}对象...",Thread.CurrentThread.ManagedThreadId,this.GetType().Name);
        }
        private static singletonTwo _singleton = null;
        static singletonTwo()//静态构造函数：由clr调用并保证在第一次使用这个类之前，调用且只调用一次（确保该类永远只被初始化一次）
        {
            _singleton = new singletonTwo();
        }
        public static singletonTwo CreateInstance()//私有化构造函数后，提供一个外界调用对象的入口
        {
            return _singleton;
        }
    }
}

 

3、代码如下：

namespace Singleton
{
    public class singletonThree
    {
        private singletonThree()//私有化构造函数的目的是为了防止外界进行实例化对象
        {
            Thread.Sleep(1000);//模拟耗时的实例化操作,常见的损耗有耗时、耗计算资源(ram,cpu等)、耗有限资源(数据库连接等)
            Console.WriteLine("线程id={0}的线程构造了{1}对象...",Thread.CurrentThread.ManagedThreadId,this.GetType().Name);
        }
        private static singletonThree _singleton = new singletonThree();//静态变量：会在第一次使用类的时候初始化，且只初始化一次
        public static singletonThree CreateInstance()//私有化构造函数后，提供一个外界调用对象的入口
        {
            return _singleton;
        }
    }
}

 4、客户类代码：

            {   //单例模式，确保一个类有且只有一个实例
                singletonOne obj0 = Singleton.singletonOne.CreateInstance();
                singletonTwo obj1 = Singleton.singletonTwo.CreateInstance();
                singletonThree obj21 = Singleton.singletonThree.CreateInstance();
                singletonThree obj21 = Singleton.singletonThree.CreateInstance();
                Console.WriteLine("obj21与obj22是否为同一对象？{0}", object.ReferenceEquals(obj21, obj22));//运行证明：单例模式返回的实例是同一个实例，操作其中一个会影响另一个
                Console.WriteLine(".............................");
            }

 5、运行结果：

四、单例模式的优缺点及使用：单例模式的目的是保证在整个进程中只使用同一个对象，该对象是常驻内存的，不会被GC回收，而普通new出来的对象会在使用完该对象之后被GC掉，不会常驻内存，因此不要滥用单例模式，可根据实际情况考虑是否采用单例模式（如果实例化一个类耗时，而且任何地方使用该实例都不会产生其他额外影响时可采用单例模式，某些地方也应该使用单例模式，比如使用数据库连接池、线程池等）。