Singleton in go

Question

How does one implement the Singleton design pattern in the go programming language?

Answer 1

Setting aside the argument of whether or not implementing the singleton pattern is a good idea, here's a possible implementation:

package singleton

type single struct {
        O interface{};
}

var instantiated *single = nil

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

single and instantiated are private, but New() is public. Thus, you can't directly instantiate single without going through New(), and it tracks the number of instantiations with the private boolean instantiated. Adjust the definition of single to taste.

However, as several others have noted, this is not thread-safe, unless you're only initializing your singleton in init(). A better approach would be to leverage sync.Once to do the hard work for you:

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
}

See also, hasan j's suggestion of just thinking of a package as a singleton. And finally, do consider what others are suggesting: that singletons are often an indicator of a problematic implementation.

Answer 2

Before trying to find a way to bend Go to your will, you might want to take a look at some articles:

• SINGLETON - the anti-pattern!

• Singletons are Pathological Liars

• Root Cause of Singletons.

In summary, over time people have found singletons to be less than optimal, and imho especially if you are trying to do any test-driven development: on many levels they are pretty much as bad as global variables.

[disclaimer: I know its not a strict answer to your question but it really is relevant]

Answer 3

Just put your variables and functions at the package level.

Also see similar question: How to make a singleton in Python

Answer 4

I think that in a concurrent world we need to be a bit more aware that these lines are not executed atomically:

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

I would follow the suggestion of @marketer and use the package "sync"

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 5

The best approach will be:

 package singleton

 import "sync"

 type singleton struct {
 }

 var instance *singleton
 var once sync.Once

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

You should read this Link

Answer 6

You can do initialization using the once package:

This will ensure that your init methods only get called once.

Answer 7

Just have a single static, final, constant, global, application-wide instance of the Object you want.

This however contradicts the OO paradigm. Its use should be limited to primitives and immutable objects, not to mutable objects.

Answer 8

You should be aware that Once.Do is serious about executing the code only once. That means, the code is always executed only once, even though it might have panicked:

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

If f (note: the once logic) panics, Do considers it to have returned; future calls of Do return without calling f.

I used mutexes instead to ensure unique initialisation of a global configuration variable to overcome this restriction:

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