第一篇：单例模式

Posted 2023-04-26

参考技术A 单例模式即一个类只拥有一个实例。

class MyClass private: MyClass() //构造函数是私有的 MyClass(const MyClass &); //拷贝和复制都是私有的 MyClass& operator=(const MyClass &); public: ~MyClass(); static MyClass* Instance(); //无关的其他成员函数和变量 private: int m_iNum; public: int GetVal()constreturn m_iNum; ;
//其中Instance()函数实现 MyClass* MyClass::Instance() static MyClass instance; return &instance;
因为构造函数是私有的，所以不能通过new来生成一个新的对象，也不能够声明一个对象。但是可以用静态方法 static MyClass* Instance()static MyClass instance; return &instance; ，这个方法声明（在类的内部，外部不能声明）了一个静态的MyClass对象，所有的对象共享一份。所以只会有一个MyClass对象。实现了单例模式。

通过判断进行单例模式
class MyClass private: MyClass(); ~MyClass() static int m_nHandleCount; //该单例对象引用次数 static MyClass *m_pHandle; public: static MyClass* GetHandle(); void releaseHandle(); //函数实现 MyClass* MyClass::GetHandle() if(m_pHandle == NULL) m_pHandle = new MyClass; if(m_pHandle != NULL) m_nHandleCount++; return m_pHandle; return NULL; //说明在new的时候出错 else m_nHandleCount++; return m_pHandle; //释放 void MyClass::releaseHandle() if(m_nHandleCount > 0) m_nHandleCount--; if(m_nHandleCount == 0) if(m_pHandle != NULL) delete m_pHandle; m_pHandle = NULL;

这两种方法实际上都是差不多

第一：单例模式

第一，单例模式是什么？

第二，为什么要使用单例模式？

第三，怎样使用单例模式？

第四，单例模式的应用场景

 

第一，单例模式是什么？

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

显然单例模式的要点有三个：

一是某个类只能有一个实例；

二是它必须自行创建这个实例（当前类中创建）；

三是它必须自行向整个系统提供这个实例（通过一个方法接口）。

 

 

第二，为什么要使用单例模式？

单例模式可以控制单例数量；可以进行有意义的派生；对实例的创建有更自由的控制;

 

第三，怎样使用单例模式？

  通过一个实例来说明（控制台应用程序）（有如下几种方式：）

  1.  私有的静态变量（被调用类）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonPattern
{
    /// <summary>
    /// 私有化构造函数
    /// 私有的静态变量
    /// 一个静态的对象创建方法

    /// </summary>
    public class Singleton
    {
        private Singleton()//构造函数私有
        {
            Console.WriteLine("初始化了？但我只能被掉一次哦,线程id={0}",Thread.CurrentThread.ManagedThreadId);
        }

        private static Singleton _Singleton = null;

        private static object Singleton_Lock = new object();

        public static Singleton CreateInstance() //双null
        {
            if (_Singleton == null)//保证对象初始化之后的所有线程，不需要等待锁
            {
                Console.WriteLine("准备进入lock");
                lock (Singleton_Lock)//保证只有一个线程进去判断
                {
                    //Thread.Sleep(1000);
                    if (_Singleton == null)//保证对象为空才真的创建
                    {
                        _Singleton = new Singleton();
                    }
                }
            }
            return _Singleton;
        }
        public void Show()
        {
            Console.WriteLine("这里调用了{0}.Show", this.GetType().Name);
        }
    }
}

   调用类：

  List<Task> taskList = new List<Task>();  //提供任务列表
            TaskFactory taskFactory = new TaskFactory();
            taskList.Add(taskFactory.StartNew(() =>
           {
               Singleton singleton = Singleton.CreateInstance();//外部不能实例化，只能内部实例化
               singleton.Show();
           }));
            Task.WaitAll(taskList.ToArray());//等待所有任务完成

2.静态构造函数：由CLR保证，在第一次使用这个类之前，调用而且只调用一次

被调用类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonPattern
{
    public class SingletonSecond
    {
        private SingletonSecond()
        {
          
            Console.WriteLine("{0}被构造，线程id={1}", this.GetType().Name, Thread.CurrentThread.ManagedThreadId);
        }

        private static SingletonSecond _Singleton = null;

        /// <summary>
        /// 静态构造函数：由CLR保证，在第一次使用这个类之前，调用而且只调用一次
        /// </summary>
        static SingletonSecond()
        {
            _Singleton = new SingletonSecond();
        }
        public static SingletonSecond CreateInstance()
        {
            return _Singleton;
        }

        public void Show()
        {
            Console.WriteLine("这里调用了{0}.Show", this.GetType().Name);
        }

    }
}

3.静态变量：会在类型第一次使用的时候初始化，而且只初始化一次

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SingletonPattern
{
    public class SingletonThird
    {
        private SingletonThird()
        {
          
            Console.WriteLine("{0}被构造，线程id={1}", this.GetType().Name, Thread.CurrentThread.ManagedThreadId);
        }

        /// <summary>
        /// 静态变量：会在类型第一次使用的时候初始化，而且只初始化一次
        /// </summary>
        private static SingletonThird _Singleton = new SingletonThird();

        public static SingletonThird CreateInstance()
        {
            return _Singleton;
        }

        public void Show()
        {
            Console.WriteLine("这里调用了{0}.Show", this.GetType().Name);
        }

    }
}

4.global.asax中也可以写（英文是启动项）

第四，单例模式的应用场景

单例模式应用的场景一般发现在以下条件下：

　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。