Padrão de design detalhado: padrão singleton

Este artigo analisa o terceiro modo mais comumente usado no modo de criação: o modo singleton. Ainda é olhar primeiro as duas fotos, revisar o tipo de modo e aprofundar a memória.

definição:

Modo Singleton: Certifique-se de que uma classe tenha apenas uma instância e forneça um ponto de acesso global para acessar essa instância exclusiva .

Padrão Singleton: Garanta que uma classe tenha apenas uma instância e forneça um ponto global de acesso a ela.

Pontos principais:

Uma classe pode ter apenas uma instância

Você mesmo deve criar esta instância

deve fornecer esta instância para todo o sistema em si

O caso prático mais simples é o gerenciador de tarefas no sistema operacional Windows e a singularidade do balanceamento de carga.

estrutura:

Classificação:

Classe singleton de estilo faminto: não há necessidade de considerar o problema de acesso simultâneo por vários threads; velocidade de chamada e tempo de resposta são melhores do que singletons de estilo preguiçoso; eficiência de utilização de recursos não é tão boa quanto singletons de estilo preguiçoso; tempo de carregamento do sistema pode ser mais longo

class EagerSingleton 
{ 
    private static EagerSingleton instance = new EagerSingleton(); 
    private EagerSingleton() { } 
    public static EagerSingleton GetInstance() 
    {
        return instance; 
    }
}

Classe singleton de estilo preguiçoso: implementa carregamento lento; deve lidar com o problema de vários threads acessando ao mesmo tempo; precisa ser controlado por mecanismos como bloqueio de verificação dupla, o que fará com que o desempenho do sistema seja afetado até certo ponto

class Singleton 
{
    private static Singleton instance=null;  
    private Singleton()
    {	
    }
	
    public static Singleton GetInstance() 
    {
        if(instance==null)
            instance=new Singleton();	
        return instance;
    }
}

Estilo preguiçoso para evitar chamadas repetidas por diferentes processos, você pode verificar o bloqueio:

class LazySingleton 
{ 
    private static LazySingleton instance = null; 

    //程序运行时创建一个静态只读的辅助对象
    private static readonly object syncRoot = new object();

    private LazySingleton() { } 

    public static LazySingleton GetInstance() 
    { 
        //第一重判断，先判断实例是否存在，不存在再加锁处理
        if (instance == null) 
        {
            //加锁的程序在某一时刻只允许一个线程访问
            lock(syncRoot)
            {
                //第二重判断
                if(instance==null)
                {
                    instance = new LazySingleton();  //创建单例实例
                }
            }
        }
        return instance; 
    }
}

Diagrama de classe:

aplicabilidade:

O sistema precisa apenas de um objeto de instância ou apenas um objeto pode ser criado devido ao consumo excessivo de recursos

Uma única instância de uma classe de chamada de cliente só pode usar um ponto de acesso público e a instância não pode ser acessada por outros meios além do ponto de acesso público

vantagem:

Fornece acesso controlado a instâncias exclusivas

Pode economizar recursos do sistema e melhorar o desempenho do sistema

Permitir número variável de instâncias ( várias classes de instância )

deficiência:

Difícil de escalar (falta de camada de abstração)

A classe Singleton tem muitas responsabilidades

Devido ao mecanismo automático de coleta de lixo, o estado de objetos singleton compartilhados pode ser perdido

---

Caso 1: (código .NET)

using System;

namespace SingletonSample
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建四个LoadBalancer对象
		    LoadBalancer balancer1,balancer2,balancer3,balancer4;
		    balancer1 = LoadBalancer.GetLoadBalancer();
		    balancer2 = LoadBalancer.GetLoadBalancer();
		    balancer3 = LoadBalancer.GetLoadBalancer();
		    balancer4 = LoadBalancer.GetLoadBalancer();
		
		    //判断服务器负载均衡器是否相同
		    if (balancer1 == balancer2 && balancer2 == balancer3 && balancer3 == balancer4) 
            {
			    Console.WriteLine("服务器负载均衡器具有唯一性！");
		    }
		
		    //增加服务器
		    balancer1.AddServer("Server 1");
		    balancer1.AddServer("Server 2");
		    balancer1.AddServer("Server 3");
		    balancer1.AddServer("Server 4");

            //模拟客户端请求的分发，如果输出结果全为同一个server，可以将i适当放大，例如改为"i < 100"
		    for (int i = 0; i < 10; i++) 
            {
                string server = balancer1.GetServer();
                Console.WriteLine("分发请求至服务器： " + server);
            }
            Console.Read();
        }
    }
}

using System;
using System.Collections;

namespace SingletonSample
{
    class LoadBalancer
    {
        //私有静态成员变量，存储唯一实例
        private static LoadBalancer instance = null;
        //服务器集合
        private ArrayList serverList = null;

        //私有构造函数
        private LoadBalancer()
        {
            serverList = new ArrayList();
        }

        //公有静态成员方法，返回唯一实例
        public static LoadBalancer GetLoadBalancer()
        {
            if (instance == null)
            {
                instance = new LoadBalancer();
            }
            return instance;
        }

        //增加服务器
        public void AddServer(string server)
        {
            serverList.Add(server);
        }

        //删除服务器
        public void RemoveServer(string server)
        {
            serverList.Remove(server);
        }

        //使用Random类随机获取服务器
        public string GetServer()
        {
            Random random = new Random();
            int i = random.Next(serverList.Count);
            return serverList[i].ToString();
        }
    }
}

Caso 2: (código JAVA)

public class Singleton {
    
    private static Singleton sing;

    private Singleton() {
        
    }
    
    public static Singleton getInstance() {
        if (sing == null) {
            sing = new Singleton();
        }
        return sing;
    }
}

public class Test {
    
    public static void main(string[] args) {
        Singleton sing = Singleton.getInstance();
        Singleton sing2 = Singleton.getInstance();
        
        System.out.println(sing);
        System.out.println(sing2);
    }
}