Método Singleton: patrones de diseño de Python

Requisito previo: patrón de diseño Singleton | Introducción

¿Qué es el método Singleton en Python?

El Método Singleton es un tipo de patrón de Diseño Creacional y es uno de los patrones de diseño más simples00 disponibles para nosotros. Es una forma de proporcionar uno y solo un objeto de un tipo particular. Se trata de una sola clase para crear métodos y especificar los objetos. 
El patrón de diseño Singleton se puede entender con un ejemplo muy simple de conectividad de base de datos. Cuando cada objeto crea una conexión de base de datos única a la base de datos, afectará en gran medida el costo y los gastos del proyecto. Por lo tanto, siempre es mejor hacer una sola conexión en lugar de hacer conexiones extra irrelevantes que se pueden hacer fácilmente con Singleton Design Pattern .

patrón singleton

Definición: El patrón singleton es un patrón de diseño que restringe la instanciación de una clase a un objeto.

Ahora echemos un vistazo a las diferentes implementaciones del patrón Singleton Design. 

Método 1: patrón de diseño Monostate/Borg Singleton

El patrón de Borg puede implementar el comportamiento de Singleton, pero en lugar de tener solo una instancia de la clase, hay varias instancias que comparten el mismo estado. Aquí no nos enfocamos en compartir la identidad de la instancia, sino que nos enfocamos en el estado compartido. 

# Singleton Borg pattern
class Borg:
 
    # state shared by each instance
    __shared_state = dict()
 
    # constructor method
    def __init__(self):
 
        self.__dict__ = self.__shared_state
        self.state = 'GeeksforGeeks'
 
    def __str__(self):
 
        return self.state
 
 
# main method
if __name__ == "__main__":
 
    person1 = Borg()    # object of class Borg
    person2 = Borg()    # object of class Borg
    person3 = Borg()    # object of class Borg
 
    person1.state = 'DataStructures'  # person1 changed the state
    person2.state = 'Algorithms'     # person2 changed the state
 
    print(person1)    # output --> Algorithms
    print(person2)    # output --> Algorithms
 
    person3.state = 'Geeks'  # person3 changed the
    # the shared state
 
    print(person1)    # output --> Geeks
    print(person2)    # output --> Geeks
    print(person3)    # output --> Geeks

Producción: 

Algorithms
Algorithms
Geeks
Geeks
Geeks

Patrón de diseño Singleton

Patrón de diseño Singleton de bloqueo de doble verificación

Es fácil notar que una vez que se crea un objeto, la sincronización del subproceso ya no es útil porque ahora el objeto nunca será igual a Ninguno y cualquier secuencia de operaciones conducirá a resultados consistentes. 
Entonces, cuando el objeto sea igual a Ninguno, solo adquiriremos el bloqueo en el método getInstance.

# Double Checked Locking singleton pattern
import threading
 
 
class SingletonDoubleChecked(object):
 
    # resources shared by each and every
    # instance
 
    __singleton_lock = threading.Lock()
    __singleton_instance = None
 
    # define the classmethod
    @classmethod
    def instance(cls):
 
        # check for the singleton instance
        if not cls.__singleton_instance:
            with cls.__singleton_lock:
                if not cls.__singleton_instance:
                    cls.__singleton_instance = cls()
 
        # return the singleton instance
        return cls.__singleton_instance
 
 
# main method
if __name__ == '__main__':
 
    # create class X
    class X(SingletonDoubleChecked):
        pass
 
    # create class Y
    class Y(SingletonDoubleChecked):
        pass
 
    A1, A2 = X.instance(), X.instance()
    B1, B2 = Y.instance(), Y.instance()
 
    assert A1 is not B1
    assert A1 is A2
    assert B1 is B2
 
    print('A1 : ', A1)
    print('A2 : ', A2)
    print('B1 : ', B1)
    print('B2 : ', B2)

Producción:  

A1 :  __main__.X object at 0x02EA2590
A2 :  __main__.X object at 0x02EA2590
B1 :  __main__.Y object at 0x02EA25B0
B2 :  __main__.Y object at 0x02EA25B0

Crear un singleton en Python

En la implementación clásica del patrón Singleton Design, simplemente usamos el método estático para crear el método getInstance que tiene la capacidad de devolver el recurso compartido. También hacemos uso del llamado Constructor Privado Virtual para plantear la excepción en su contra aunque no es muy requerido.

# classic implementation of Singleton Design pattern
class Singleton:
 
    __shared_instance = 'GeeksforGeeks'
 
    @staticmethod
    def getInstance():
        """Static Access Method"""
        if Singleton.__shared_instance == 'GeeksforGeeks':
            Singleton()
        return Singleton.__shared_instance
 
    def __init__(self):
        """virtual private constructor"""
        if Singleton.__shared_instance != 'GeeksforGeeks':
            raise Exception("This class is a singleton class !")
        else:
            Singleton.__shared_instance = self
 
 
# main method
if __name__ == "__main__":
 
    # create object of Singleton Class
    obj = Singleton()
    print(obj)
 
    # pick the instance of the class
    obj = Singleton.getInstance()
    print(obj)

Producción:  

 __main__.Singleton object at 0x014FFE90
 __main__.Singleton object at 0x014FFE90

Diagrama de clase

Diagrama de clase del patrón de diseño Singleton 

diagrama de clase singleton

Ventajas de utilizar el Método Singleton: 

1. Inicializaciones: un objeto creado por el método Singleton se inicializa solo cuando se solicita por primera vez.
2. Acceso al objeto: Obtuvimos acceso global a la instancia del objeto.
3. Recuento de instancias: en singleton, las clases de métodos no pueden tener más de una instancia

Desventajas de usar el Método Singleton: 

1. Entorno multihilo: no es fácil usar el método singleton en un entorno multihilo, porque tenemos que tener cuidado de que el multihilo no cree un objeto singleton varias veces.
2. Principio de responsabilidad única: como el método Singleton resuelve dos problemas a la vez, no sigue el principio de responsabilidad única.
3. Proceso de prueba unitaria: a medida que introducen el estado global en la aplicación, hace que la prueba unitaria sea muy difícil.

Aplicabilidad

1. Control sobre las variables globales: en los proyectos en los que específicamente necesitamos un fuerte control sobre las variables globales, se recomienda encarecidamente utilizar el método Singleton .
2. Uso diario de los desarrolladores: los patrones Singleton generalmente se usan para proporcionar el registro, el almacenamiento en caché, los grupos de subprocesos y los ajustes de configuración y, a menudo, se usan junto con los patrones de diseño de Factory.

Lea más: método Singleton en Java , prácticas de patrón de diseño Singleton con ejemplos