Los patrones de diseño son soluciones probadas a problemas comunes que surgen en el diseño de software. Proporcionan una plantilla o guía para resolver estos problemas de forma flexible y reutilizable.

Cada patrón representa una práctica recomendada que los desarrolladores pueden adaptar a su contexto específico. Los patrones de diseño a menudo se clasifican en tres categorías principales.

Para comenzar esta serie, hablemos del patrón Singleton.

Semifallo

El patrón Singleton garantiza que una clase tenga solo una instancia y proporciona un punto de acceso global a esa instancia.

Esto es útil en casos en los que necesita administrar un recurso compartido, como conexiones de bases de datos o ajustes de configuración.

Declaración del problema

A menudo existe la necesidad de garantizar que solo exista una instancia de una clase, como cuando se administran configuraciones o se interactúa con recursos de hardware. Sin Singleton, la creación de varias instancias puede generar problemas como datos inconsistentes o bloqueos de recursos.

Esto es muy común que suceda cuando se trabaja con código asincrónico, donde múltiples gorutinas pueden crear nuevas instancias de una clase o acceder a recursos compartidos.

Ejemplo del mundo real

Considere un grupo de conexiones de base de datos: si varias partes de su aplicación crean nuevas conexiones al mismo tiempo, puede terminar con interacciones de bases de datos redundantes o conflictivas. Un Singleton garantiza que solo se cree y utilice una conexión en toda la aplicación.

Implementación

package main

import (
    "fmt"
    "sync"
)

type Singleton interface {
    DoSomething() string
}

type singleton struct{}

var lock = &sync.Mutex{}

var instance *singleton

func NewSingletonInstance() *singleton {
    if instance == nil {
        lock.Lock()
        defer lock.Unlock()
        if instance == nil {
            fmt.Println("Creating single instance now.")
            instance = &singleton{}
        } else {
            fmt.Println("Single instance already created.")
        }
    } else {
        fmt.Println("Single instance already created.")
    }

    return instance
}

func (s *singleton) DoSomething() string {
    return "Doing something."
}

func main() {
    instance1 := NewSingletonInstance()
    instance2 := NewSingletonInstance()
    fmt.Printf("%p\n", instance1)
    fmt.Printf("%p\n", instance2)
}

La función NewSingletonInstance garantiza que solo se cree una instancia de singleton, incluso cuando se llama varias veces.

• Primero, verifica si la instancia es nula (es decir, aún no se ha creado ninguna instancia).
• Si la instancia es nula, bloquea la sección de código usando lock.Lock() para evitar que varias rutinas ingresen a esta sección simultáneamente.
• Después del bloqueo, se realiza una segunda verificación para garantizar que ninguna otra rutina haya creado la instancia entre la primera verificación y el momento en que se adquirió el bloqueo.
• Si la instancia aún es nula, se crea una nueva instancia singleton y se asigna a la variable global.
• sync.Mutex y el bloqueo de doble verificación garantizan que la creación de la instancia singleton sea segura para subprocesos, lo que evita que múltiples goroutines creen instancias separadas.