Designmuster sind bewährte Lösungen für häufige Probleme, die beim Softwaredesign auftreten. Sie bieten eine Vorlage oder einen Leitfaden zur flexiblen und wiederverwendbaren Lösung dieser Probleme.

Jedes Muster stellt eine Best Practice dar, die Entwickler an ihren spezifischen Kontext anpassen können. Entwurfsmuster werden oft in drei Hauptkategorien eingeteilt.

Um diese Serie anzukurbeln, sprechen wir über das Singleton-Muster.

Singleton

Das Singleton-Muster stellt sicher, dass eine Klasse nur eine Instanz hat und bietet einen globalen Zugriffspunkt auf diese Instanz.

Dies ist in Fällen nützlich, in denen Sie eine gemeinsam genutzte Ressource verwalten müssen, z. B. Datenbankverbindungen oder Konfigurationseinstellungen.

Problemstellung

Oft muss sichergestellt werden, dass nur eine Instanz einer Klasse vorhanden ist, beispielsweise bei der Verwaltung von Konfigurationen oder der Interaktion mit Hardwareressourcen. Ohne Singleton kann die Erstellung mehrerer Instanzen zu Problemen wie inkonsistenten Daten oder Ressourcensperren führen.

Dies kommt sehr häufig vor, wenn mit asynchronem Code gearbeitet wird, bei dem mehrere Goroutinen neue Instanzen einer Klasse erstellen oder auf gemeinsam genutzte Ressourcen zugreifen können.

Beispiel aus der Praxis

Erwägen Sie einen Datenbankverbindungspool: Wenn mehrere Teile Ihrer Anwendung gleichzeitig neue Verbindungen erstellen, kann es zu redundanten oder widersprüchlichen Datenbankinteraktionen kommen. Ein Singleton stellt sicher, dass in der gesamten Anwendung nur eine Verbindung erstellt und verwendet wird.

Durchführung

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

Die Funktion NewSingletonInstance stellt sicher, dass nur eine Instanz von Singleton erstellt wird, auch wenn sie mehrmals aufgerufen wird.

• Zuerst wird geprüft, ob die Instanz Null ist (d. h. es wurde noch keine Instanz erstellt).
• Wenn die Instanz Null ist, wird der Codeabschnitt mit lock.Lock() gesperrt, um zu verhindern, dass mehrere Goroutinen gleichzeitig auf diesen Abschnitt zugreifen.
• Nach der Sperrung wird eine zweite Prüfung durchgeführt, um sicherzustellen, dass zwischen der ersten Prüfung und dem Erwerb der Sperre keine andere Goroutine die Instanz erstellt hat.
• Wenn die Instanz immer noch Null ist, wird eine neue Singleton-Instanz erstellt und der globalen Variablen zugewiesen.
• Der sync.Mutex und die doppelt überprüfte Sperrung stellen sicher, dass die Erstellung der Singleton-Instanz threadsicher ist und verhindern, dass mehrere Goroutinen separate Instanzen erstellen.