Os padrões de design são soluções testadas e comprovadas para problemas comuns que surgem no design de software. Eles fornecem um modelo ou guia para resolver esses problemas de forma flexível e reutilizável.

Cada padrão representa uma prática recomendada que os desenvolvedores podem adaptar ao seu contexto específico. Os padrões de design são frequentemente classificados em três categorias principais.

Para iniciar esta série, vamos falar sobre o padrão Singleton.

Solteiro

O padrão Singleton garante que uma classe tenha apenas uma instância e fornece um ponto global de acesso a essa instância.

Isso é útil nos casos em que você precisa gerenciar um recurso compartilhado, como conexões de banco de dados ou definições de configuração.

Declaração do problema

Muitas vezes há a necessidade de garantir que exista apenas uma instância de uma classe, como ao gerenciar configurações ou interagir com recursos de hardware. Sem o Singleton, a criação de múltiplas instâncias pode levar a problemas como dados inconsistentes ou bloqueios de recursos.

Isso é muito comum de acontecer ao trabalhar com código assíncrono, onde múltiplas goroutines podem criar novas instâncias de uma classe ou acessar recursos compartilhados.

Exemplo do mundo real

Considere um pool de conexões de banco de dados: se várias partes do seu aplicativo criarem novas conexões ao mesmo tempo, você poderá acabar com interações de banco de dados redundantes ou conflitantes. Um Singleton garante que apenas uma conexão seja criada e usada em todo o aplicativo.

Implementação

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)
}

A função NewSingletonInstance garante que apenas uma instância de singleton seja criada, mesmo quando chamada várias vezes.

• Primeiro, ele verifica se a instância é nula (ou seja, nenhuma instância foi criada ainda).
• Se a instância for nula, ela bloqueia a seção de código usando lock.Lock() para evitar que vários goroutines entrem nesta seção simultaneamente.
• Após o bloqueio, uma segunda verificação é realizada para garantir que nenhuma outra goroutine criou a instância entre a primeira verificação e o momento em que o bloqueio foi adquirido.
• Se a instância ainda for nula, uma nova instância singleton será criada e atribuída à variável global.
• O sync.Mutex e o bloqueio verificado duas vezes garantem que a criação da instância singleton seja segura para threads, evitando que vários goroutines criem instâncias separadas.