Une analyse approfondie du modèle singleton en langage Go

Le modèle singleton est un modèle de conception courant qui permet de créer une seule instance dans le système pour contrôler l'accès à certaines ressources. Dans le langage Go, il existe de nombreuses façons d'implémenter le modèle singleton. Cet article vous donnera une compréhension approfondie de l'implémentation du modèle singleton dans le langage Go.

Qu'est-ce que le modèle singleton ?

Le modèle singleton fait référence à un design pattern qui ne permet la création que d'un seul objet. Il est généralement utilisé pour contrôler l'accès à certaines ressources, telles que les connexions à la base de données, les pools de threads, etc. Grâce au mode singleton, vous pouvez garantir qu'une seule instance existe dans le système et fournir un point d'accès global à utiliser par d'autres objets.

Comment implémenter le modèle singleton dans Go

Le langage Go propose diverses façons d'implémenter le modèle singleton, notamment les méthodes suivantes :

Méthode 1 : style paresseux

Le style paresseux est un style courant. L’implémentation d’un modèle singleton se caractérise par la création d’une instance singleton lors de sa première utilisation. La méthode d'implémentation est la suivante :

package singleton

import "sync"

var (
	instance *Singleton
	once     sync.Once
)

type Singleton struct {
}

func GetInstance() *Singleton {
	once.Do(func() {
		instance = &Singleton{}
	})

	return instance
}

Dans le code ci-dessus, nous définissons une structure nommée Singleton et l'instancions comme instance. En même temps, utilisez l'objet sync.Once une fois dans le package de synchronisation pour implémenter une logique qui n'est exécutée qu'une seule fois pendant le cycle de vie du programme. Lorsque GetInstance est appelée pour la première fois, la méthode Do de Sync.Once appellera la fonction transmise. La logique de cette fonction est d'instancier l'objet Singleton et de l'attribuer à l'instance. Lors des appels ultérieurs à GetInstance, puisque l’instance a déjà été instanciée, elle ne sera pas recréée.

Méthode 2 : Style chinois affamé

Le style chinois affamé est une autre façon courante d'implémenter le modèle singleton. Sa caractéristique est qu'une instance singleton est créée au démarrage du système et l'instance est renvoyée directement lorsqu'elle est appelée. La méthode d'implémentation est la suivante :

package singleton

var instance *Singleton = &Singleton{}

type Singleton struct {
}

func GetInstance() *Singleton {
	return instance
}

Dans le code ci-dessus, nous avons créé un objet Singleton lors de l'initialisation du package et l'avons attribué comme instance. La méthode GetInstace renvoie directement l'instance, de sorte que chaque appel renvoie le même objet, atteignant ainsi l'objectif de contrôler l'instance d'objet.

Méthode 3 : Verrouillage à double vérification

Le verrouillage à double vérification est une méthode d'implémentation en mode singleton utilisée dans un environnement multithread. Sa caractéristique est de vérifier d'abord s'il existe déjà une instance, et sinon, de saisir l'instance. bloc de code de synchronisation pour le créer. La méthode d'implémentation est la suivante :

package singleton

import "sync"

var (
	instance *Singleton
	mu       sync.Mutex
)

type Singleton struct {
}

func GetInstance() *Singleton {
	if instance == nil {
		mu.Lock()
		defer mu.Unlock()
		if instance == nil {
			instance = &Singleton{}
		}
	}
	return instance
}

Dans le code ci-dessus, nous utilisons un verrou mutex pour implémenter le contrôle de concurrence afin de garantir qu'un seul thread peut accéder aux ressources critiques dans un environnement multithread. Dans le même temps, un mécanisme de double contrôle est utilisé pour réduire la fréquence d'utilisation du verrouillage mutex.

Exemple

Grâce à l'exemple suivant, nous pouvons comprendre comment utiliser le modèle singleton pour implémenter la mise en cache des données.

package main

import (
	"fmt"
	"sync"
)

type Cache struct {
	store map[string]string
	mu    sync.Mutex
}

var instance *Cache

func GetCacheInstance() *Cache {
	if instance == nil {
		instance = &Cache{
			store: make(map[string]string),
		}
	}
	return instance
}

func (c *Cache) Get(key string) (string, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()

	val, ok := c.store[key]
	return val, ok
}

func (c *Cache) Set(key, val string) {
	c.mu.Lock()
	defer c.mu.Unlock()

	c.store[key] = val
}

func main() {
	cache := GetCacheInstance()

	cache.Set("name", "Tom")
	if val, ok := cache.Get("name"); ok {
		fmt.Println(val)
	}
}

Dans le code ci-dessus, nous définissons une structure Cache pour représenter la mise en cache des données. Le cache contient des variables membres du Store pour stocker les paires clé-valeur et utilise mutex mu pour contrôler l'accès. La fonction GetCacheInstance renvoie une instance Cache, qui représente le cache de données. Lorsqu'elle est appelée pour la première fois, l'instance sera instanciée dans un objet Cache. La fonction principale de l'exemple montre comment utiliser un objet Cache singleton pour stocker et récupérer des données.

Résumé

Le modèle singleton est un modèle de conception courant qui garantit qu'une seule instance existe dans le système et fournit un point d'accès global. Dans le langage Go, il existe de nombreuses façons d'implémenter le modèle singleton, notamment le style paresseux, le style affamé, le verrouillage à double vérification, etc. A travers cet article, nous comprenons les détails spécifiques de ces méthodes de mise en œuvre et implémentons un exemple de mise en cache des données.

Apprentissage recommandé : Tutoriel Golang

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!