Go 4 modes Singleton

Paresseux——Sécurité non threadée

Sécurité non threadée,Cela signifie que plusieurs objets peuvent être créés sous Multithreading.

//Utilisation de structures au lieu de classes
type Tool struct {
    values int
}

//Créer une variable privée
var instance *Tool

//Méthode d'obtention d'un objet Singleton,La transmission de référence renvoie
func GetInstance() *Tool {
    if instance == nil {
        instance = new(Tool)
    }
    return instance
}

En termes de sécurité non - thread,Utilisation Sync.Mutex Le verrouillage assure la sécurité du fil,Mais comme la méthode est verrouillée chaque fois qu'elle est appelée,Pas très efficace sur le plan des performances

//Objet de verrouillage
var lock sync.Mutex

//Le verrouillage assure la sécurité du fil
func GetInstance() *Tool {
    lock.Lock()
    defer lock.Unlock()
    if instance == nil {
        instance = new(Tool)
    }

    return instance
}

Type affamé

Créer des objets directement,Il n'est pas nécessaire de juger en blanc,C'est aussi thread Safe,Le seul inconvénient est que l'objet est créé lors de l'importation du paquet,Et il est resté en mémoire.

GoLe chinois affamé peut être utilisé init Fonctions,Vous pouvez également utiliser des variables globales.

type cfg struct {
}
var cfg *config
func init()  {
   cfg = new(config)
}
// NewConfig  Fournir un moyen d'obtenir une instance 
func NewConfig() *config {
   return cfg
}
type config struct {  
}
//Variables globales
var cfg *config = new(config)
// NewConfig  Fournir un moyen d'obtenir une instance 
func NewConfig() *config {
   return cfg
}

Double contrôle

C'est comme un paresseux. （Sécurité des fils）Sur la base de, Réduction des opérations de verrouillage , Assurer la sécurité des fils sans affecter les performances .

//Objet de verrouillage
var lock sync.Mutex

// Pour la première fois, le jugement n'est pas verrouillé , La deuxième serrure assure la sécurité du fil , Une fois l'objet créé , Obtenir des objets sans verrouillage .
func GetInstance() *Tool {
    if instance == nil {
        lock.Lock()
        if instance == nil {
            instance = new(Tool)
        }
        lock.Unlock()
    }
    return instance
}

sync.Once

Adoption sync.Once Pour s'assurer que la méthode de création de l'objet n'est exécutée qu'une seule fois

var once sync.Once

func GetInstance() *Tool {
    once.Do(func() {
        instance = new(Tool)

    })
    return instance
}

sync.Once L'intérieur est aussi essentiellement un moyen de double contrôle , Mais il serait plus concis dans l'écriture que d'écrire votre propre double vérification ,Voici Once Source de

func (o *Once) Do(f func()) {
　　// Déterminer si la méthode a été appliquée , Si elle est exécutée, elle ne l'est pas 
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
　　//Pour verrouiller,Encore un jugement,Si ce n'est pas fait, Le drapeau a été balayé et la méthode a été appelée 
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}