Singleton dans go

Question

Comment peut-on implémenter le modèle de conception Singleton dans le langage de programmation go?

Answer 1

Mis à part l'argument de savoir si ou non la mise en œuvre du modèle singleton est une bonne idée, voici une mise en œuvre possible:

package singleton 

type single struct { 
     O interface{}; 
} 

var instantiated *single = nil 

func New() *single { 
     if instantiated == nil { 
       instantiated = new(single); 
     } 
     return instantiated; 
} 

single et instantiated sont privées, mais New() est public. Ainsi, vous ne pouvez pas instancier directement single sans passer par New() et suivre le nombre d'instanciations avec le booléen privé instantiated. Ajuster la définition de single au goût.

Toutefois, comme plusieurs autres ont noted, ce n'est pas sûr pour les threads, sauf si vous initialisez uniquement votre singleton dans init(). Une meilleure approche serait de tirer parti de sync.Once pour faire le travail pour vous:

package singleton 

import "sync" 

type single struct { 
     O interface{}; 
} 

var instantiated *single 
var once sync.Once 

func New() *single { 
     once.Do(func() { 
       instantiated = &single{} 
     }) 
     return instantiated 
} 

Voir aussi la suggestion de hasan j de penser juste d'un paquet comme un singleton. Enfin, considérons ce que les autres suggèrent: les singletons sont souvent un indicateur d'une mise en œuvre problématique.

Answer 2

Avant d'essayer de trouver un moyen de se plier à votre volonté Allez, vous voudrez peut-être jeter un oeil à certains articles:

• SINGLETON - the anti-pattern!

• Singletons are Pathological Liars

• Root Cause of Singletons.

En résumé, plus de temps que les gens ont trouvé singletons d'être optimales, et à mon avis surtout si vous essayez de faire tout développement piloté par les tests: à plusieurs niveaux, ils sont à peu près aussi mauvais que mondial variables

[Avertissement: Je sais que ce ne est pas une réponse stricte à votre question, mais il est vraiment pertinent]

Answer 3

Il suffit de mettre vos variables et fonctions au niveau du package.

Voir aussi la même question: How to make a singleton in Python

Answer 4

tout simplement avoir une seule statique, finale, constante, globale, à l'échelle d'instance d'application de l'objet que vous voulez.

Ceci contredit cependant le paradigme OO. Son utilisation devrait être limitée aux primitives et aux objets immuables, pas aux objets mutables.

Answer 5

Vous pouvez faire l'initialisation à l'aide du once package:

Cela garantira que vos méthodes d'initialisation ne s'appellent une fois.

Answer 6

Je pense que dans un monde en même temps, nous devons être un peu plus conscient que ces lignes ne sont pas exécutées atomiquement:

if instantiated == nil { 
    instantiated = new(single); 
} 

je suivrais la suggestion de @marketer et utiliser le package « synchronisation »

import "sync" 

type MySingleton struct { 

} 

var _init_ctx sync.Once 
var _instance *MySingleton 

func New() * MySingleton { 
    _init_ctx.Do(func() { _instance = new(MySingleton) } ) 
    return _instance 
} 

Answer 7

La meilleure approche sera:

package singleton 

import "sync" 

type singleton struct { 
} 

var instance *singleton 
var once sync.Once 

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

Vous devriez lire Link

Answer 8

Vous devez être conscient que Once.Do est sérieux au sujet de l'exécution du code qu'une seule fois. Cela signifie, le code est toujours exécuté qu'une seule fois, même si elle aurait pu paniquer:

de https://golang.org/pkg/sync/#Once.Do

Si f (note: la logique une fois) paniques, Do estime avoir retourné; les futurs appels de Do reviennent sans appeler f.

J'ai utilisé mutex au lieu d'assurer l'initialisation unique d'une variable de configuration globale pour surmonter cette restriction:

• https://golang.org/pkg/sync/#Mutex
• https://gobyexample.com/mutexes