Aller aux modèles de conception #Singleton

Les modèles de conception sont des solutions éprouvées aux problèmes courants qui surviennent dans la conception de logiciels. Ils fournissent un modèle ou un guide pour résoudre ces problèmes de manière flexible et réutilisable.

Chaque modèle représente une bonne pratique que les développeurs peuvent adapter à leur contexte spécifique. Les modèles de conception sont souvent classés en trois catégories principales.

Pour lancer cette série, parlons du modèle Singleton.

Singleton

Le modèle Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance.

Ceci est utile dans les cas où vous devez gérer une ressource partagée, telle que les connexions à une base de données ou les paramètres de configuration.

Énoncé du problème

Il est souvent nécessaire de s'assurer qu'une seule instance d'une classe existe, par exemple lors de la gestion des configurations ou de l'interaction avec des ressources matérielles. Sans Singleton, la création de plusieurs instances peut entraîner des problèmes tels que des données incohérentes ou des verrous de ressources.

Cela se produit très souvent lorsque vous travaillez avec du code asynchrone, où plusieurs goroutines peuvent créer de nouvelles instances d'une classe ou accéder à des ressources partagées.

Exemple concret

Envisagez un pool de connexions à la base de données : si plusieurs parties de votre application créent de nouvelles connexions en même temps, vous risquez de vous retrouver avec des interactions de base de données redondantes ou conflictuelles. Un Singleton garantit qu'une seule connexion est créée et utilisée dans l'application.

Mise en œuvre

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 fonction NewSingletonInstance garantit qu'une seule instance de singleton est créée, même lorsqu'elle est appelée plusieurs fois.

• Tout d'abord, il vérifie si l'instance est nulle (c'est-à-dire qu'aucune instance n'a encore été créée).
• Si l'instance est nulle, il verrouille la section de code à l'aide de lock.Lock() pour empêcher plusieurs goroutines d'entrer simultanément dans cette section.
• Après le verrouillage, une deuxième vérification est effectuée pour s'assurer qu'aucune autre goroutine n'a créé l'instance entre la première vérification et le moment où le verrou a été acquis.
• Si l'instance est toujours nulle, une nouvelle instance singleton est créée et affectée à la variable globale.
• Le verrouillage sync.Mutex et la double vérification garantissent que la création de l'instance singleton est thread-safe, empêchant plusieurs goroutines de créer des instances distinctes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!