Padrões de Design: Notas de Padrão Singleton

1. Modo único

• uma aulaApenas um objeto pode ser criado, o padrão de design dessa classe é chamado de padrão singleton, o que garanteno sistemaa classeSó pode haver uma instância(eCompartilhamento de processo pai-filho), uma classe singleton típica é o pool de memória de C++STL
• As ideias básicas de design do modo singleton C++:
  • privatizaçãoConstrutor, exclua o padrãoconstrutor de cópiaesobrecarga do operador de atribuiçãoImpedir que objetos sejam criados e copiados diretamente
  • Os recursos de memória do objeto singleton podem ser liberados pelo sistema operacional ou o destruidor pode ser personalizado para concluir operações especiais

2. Duas implementações do modo singleton

modo homem faminto

• Turma solteira faminta no programaantes de entrar na função principalcria uma instância ú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;

• HungerSingletondevariável de membro estáticosimum objeto (ou ponteiro) de seu próprio tipo,Categoriavariável de membro estáticoA inicialização é concluída antes de entrar na função principal. Como o construtor é privatizado, objetos desta classe não podem ser criados durante a execução do programa.
• Vantagens do modo Hungry Singleton:
  • porqueProcessos filhos só podem ser criados na função principal, então a turma solteira famintaNão há problemas de segurança de thread, sem competir por recursos do sistema com classes de outros threads, emEm um ambiente multithread de alta simultaneidadeCapaz de executar tarefas com mais eficiência
• Desvantagens do padrão Hungry Singleton:
  • Se houver múltiplas classes singleton em um programa, nósnenhum controle sobre sua ordem de inicialização
  • A classe singleton faminta diminuirá a velocidade de inicialização do programa e, mesmo que a classe não seja usada, uma instância será criada, o que pode causar desperdício de memória

modo preguiçoso

• classe singleton preguiçosa no programaDepois de entrar na função principalCabe ao código subsequente decidir se deseja criar uma instância

//懒汉单例模式
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()A classe criará uma instância quando a interface do membro for chamada pela primeira vez
• Vantagens do padrão singleton preguiçoso:
  • capaz de controlarA ordem de inicialização de vários objetos de classe singleton preguiçosos, e criado apenas quando necessário, evitando desperdício de memória
• Desvantagens do padrão singleton preguiçoso:
  • Existem problemas de segurança de thread em um ambiente multithread e bloqueios são necessários