Patrones de diseño: notas del patrón Singleton

1. Modo singleton

• una claseSólo se puede crear un objeto, el patrón de diseño de dicha clase se llama patrón singleton, que garantizaen el sistemala claseSólo puede haber una instancia(yCompartir procesos entre padres e hijos), una clase singleton típica es el grupo de memoria de C++ STL
• Las ideas básicas de diseño del modo singleton de C++:
  • privatizaciónConstructor, elimina el valor predeterminadoconstructor de copiasysobrecarga del operador de asignaciónEvitar que los objetos se creen y copien directamente
  • El sistema operativo puede liberar los recursos de memoria del objeto singleton o personalizar el destructor para completar operaciones especiales.

2. Dos implementaciones del modo singleton

modo hombre hambriento

• Clase soltera hambrienta en el programa.antes de entrar a la función principalcrea una instancia única de

//饿汉单例模式
class HungerSingleton
{
    
    
public:
	//定义一个可以访问单例对象的静态接口
	static HungerSingleton* Getinstance()
	{
    
    
		return &singleObj;
	}
private:
	//构造函数私有化,防止对象被直接创建
	HungerSingleton() {
    
     cout << "单例对象创建" << endl; }
	//删除拷贝接口,防止对象被拷贝
	HungerSingleton(const HungerSingleton& single) = delete;
	HungerSingleton& operator=(const HungerSingleton& single) = delete;

private:
	//定义静态区的HungerSingleton成员
	static HungerSingleton singleObj;
	//也可以定义成指针,初始化时在堆上创建
	//static HungerSingleton* singleObj;
};
//初始化类的静态成员
HungerSingleton HungerSingleton::singleObj;
//初始化时在堆上创建
//HungerSingleton * HungerSingleton::singleObj = new HungerSingleton;

• HungerSingletondevariable miembro estáticaSíun objeto (o puntero) de su propio tipo,Categoríavariable miembro estáticaLa inicialización se completa antes de ingresar a la función principal. Dado que el constructor está privatizado, no se pueden crear objetos de esta clase durante la ejecución del programa.
• Ventajas del modo Hungry Singleton:
  • porqueLos procesos secundarios solo se pueden crear en la función principal., entonces la clase singleton hambrientaNo hay problemas de seguridad de subprocesos, sin competir por los recursos del sistema con clases de otros subprocesos, enEn un entorno multiproceso de alta concurrenciaCapaz de realizar tareas de manera más eficiente.
• Desventajas del patrón Singleton hambriento:
  • Si hay varias clases singleton en un programa,sin control sobre su orden de inicialización
  • La clase singleton hambrienta ralentizará la velocidad de inicio del programa e incluso si no se utiliza la clase, se creará una instancia, lo que puede provocar un desperdicio de memoria.

modo perezoso

• clase singleton perezosa en el programaDespués de ingresar a la función principalDepende del código posterior decidir si se crea una instancia

//懒汉单例模式
class LazySingleton
{
    
    
public:
	//定义一个可以访问单例对象的静态接口
	static LazySingleton* Getinstance()
	{
    
    
		//若singleObj为空指针则创建单例对象
		if (singleObj == nullptr)
		{
    
    
			singleObj = new LazySingleton;
		}
		return singleObj;
	}
private:
	//构造函数私有化,防止对象被创建
	LazySingleton() {
    
     cout << "单例对象创建" << endl; }
	//删除拷贝接口,防止对象被拷贝
	LazySingleton(const LazySingleton& single) = delete;
	LazySingleton& operator=(const LazySingleton& single) = delete;

private:
	//定义成静态成员指针,初始化时在堆上创建
	static LazySingleton* singleObj;
};
//初始化时设置成空指针
LazySingleton * LazySingleton::singleObj = nullptr;

• LazySingletonGetinstance()La clase creará una instancia cuando se llame a la interfaz miembro por primera vez.
• Ventajas del patrón singleton perezoso:
  • capaz de controlarEl orden de inicialización de varios objetos de clase singleton diferidos.y solo se crea cuando es necesario, evitando el desperdicio de memoria
• Desventajas del patrón singleton perezoso:
  • Hay problemas de seguridad de subprocesos en un entorno de subprocesos múltiples y se requieren bloqueos