What are the implementation methods of singleton pattern in Golang?

There are three ways to implement the singleton mode in Golang: lazy mode, hungry mode and double check mode. Next, we will introduce these three implementation methods in detail and provide specific code examples.

1. Lazy mode

Lazy mode means that a singleton instance is created only when it is called for the first time. The following is a sample code of lazy mode:

package singleton

import (
    "sync"
)

type Singleton struct {
}

var instance *Singleton
var once sync.Once

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

In In this code, the GetInstance function uses the Once structure in the sync package to ensure that the instance is only created when it is called for the first time. When implementing lazy mode, you need to pay attention to concurrency safety.

2. Hungry Man Mode

Hungry Man Mode refers to creating a single instance when the program starts. The following is a sample code of Hungry Man Mode:

package singleton

type Singleton struct {
}

var instance *Singleton = &Singleton{}

func GetInstance() *Singleton {
    return instance
}

In In this code, instance is created when the program starts. Since the init function of the Go language is automatically called when the package is imported, the hungry mode can be realized.

3. Double-Checked Locking

Double-check mode is a way to optimize based on the lazy mode, and realizes the singleton of the lazy mode through double checking. The following is a sample code of double check mode:

package singleton

import "sync"

type Singleton struct {
}

var instance *Singleton
var mu sync.Mutex

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

In this code, sync.Mutex is used to ensure concurrency safety, and double check is used to implement the singleton mode of lazy mode.

The above are the three implementation methods of singleton mode in Golang: lazy mode, hungry mode and double check mode. Choose an appropriate implementation method to implement the singleton pattern based on actual needs and performance requirements.

The above is the detailed content of What are the implementation methods of singleton pattern in Golang?. For more information, please follow other related articles on the PHP Chinese website!