Go four singleton modes

Slacker type —— Non-thread safety

Non-thread safety , It means that multiple objects may be created under multithreading .

// Use structs instead of classes 
type Tool struct {
    values int
}

// Create private variables 
var instance *Tool

// Methods to get singleton objects , Reference passing returns 
func GetInstance() *Tool {
    if instance == nil {
        instance = new(Tool)
    }
    return instance
}

On a non thread safe basis , utilize Sync.Mutex Lock to ensure thread safety , However, every time this method is called, a lock operation is performed , Not very efficient in performance

// Lock object 
var lock sync.Mutex

// Lock to ensure thread safety 
func GetInstance() *Tool {
    lock.Lock()
    defer lock.Unlock()
    if instance == nil {
        instance = new(Tool)
    }

    return instance
}

Hungry Chinese style

Create objects directly , There is no need to judge that it is empty , It is also thread safe , The only drawback is that the object is created at the same time as the package is imported , And continue to occupy the memory .

Go Language hungry Chinese style can be used init function , You can also use global variables .

type cfg struct {
}
var cfg *config
func init()  {
   cfg = new(config)
}
// NewConfig  Provides a method to get an instance 
func NewConfig() *config {
   return cfg
}
type config struct {  
}
// Global variables 
var cfg *config = new(config)
// NewConfig  Provides a method to get an instance 
func NewConfig() *config {
   return cfg
}

Double check

In the lazy style （ Thread safety ） On the basis of the optimization , Reduce the operation of locking , Ensure thread safety without affecting performance .

// Lock object 
var lock sync.Mutex

// The first judgment is not locked , The second locking ensures thread safety , Once the object is created , There is no need to lock the object .
func GetInstance() *Tool {
    if instance == nil {
        lock.Lock()
        if instance == nil {
            instance = new(Tool)
        }
        lock.Unlock()
    }
    return instance
}

sync.Once

adopt sync.Once To ensure that the object creation method is executed only once

var once sync.Once

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

    })
    return instance
}

sync.Once Internal is also a way of double inspection in essence , But in terms of writing, it will be more concise than writing double check by yourself , Here are Once Source code

func (o *Once) Do(f func()) {
　　// Determine whether the method has been implemented , If it has been executed, it will not be executed 
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
　　// To lock , Make another judgment , If not implemented , Then mark that the line has been scanned and call the method 
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}