Go 中的单例

Question

如何在Go语言中实现单例设计模式？

Answer 1

抛开实现单例模式是否是个好主意的争论，这里有一个可能的实现：

package singleton

type single struct {
        O interface{};
}

var instantiated *single = nil

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

single 和 instantiated 是私有的，但 New()< /code> 是公开的。因此，您无法在不通过 New() 的情况下直接实例化 single，并且它会使用私有布尔值 instantiated 来跟踪实例化的数量。根据喜好调整 single 的定义。

然而，正如其他几个人指出的，这不是线程安全的，除非您仅在 init() 中初始化您的单例。更好的方法是利用 sync.Once 来为您完成艰苦的工作：

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
}

另请参阅 hasan j 的建议，即仅将包视为单例。最后，请考虑其他人的建议：单例通常是有问题的实现的指标。

Answer 2

最好的方法是：

 package singleton

 import "sync"

 type singleton struct {
 }

 var instance *singleton
 var once sync.Once

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

您应该阅读此链接

Answer 3

只需将变量和函数放在包级别即可。

另请参阅类似的问题：How to make a singleton in Python

Answer 4

我认为在并发世界中，我们需要更加意识到这些行不是自动执行的：

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

我会遵循@marketer的建议并使用包“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

在尝试找到一种方法来屈服于你的意愿之前，你可能需要看看一些文章：

• SINGLETON - 反模式！

• 单身人士都是病态的骗子

• 单例的根本原因。

总之，随着时间的推移，人们发现单例并不是最佳的，恕我直言，尤其是如果您尝试进行任何测试驱动的开发：在许多层面上，它们几乎与全局变量一样糟糕。

[免责声明：我知道这不是对你的问题的严格回答，但它确实相关]

Answer 6

正如您在以下代码中看到的那样，很简单：

package main

import (
    "fmt"
    "sync"
)

type singleton struct {
    count int
    sync.RWMutex
}

var instance singleton 

func GetInstance() *singleton {
    return &instance 
}

func (s *singleton) AddOne() {
    s.Lock()
    defer s.Unlock()
    s.count++
}

func (s *singleton) GetCount() int {
    s.RLock()
    defer s.RUnlock()
    return s.count
}

func main() {
    obj1 := GetInstance()
    obj1.AddOne()
    fmt.Println(obj1.GetCount())
    obj2 := GetInstance()
    obj2.AddOne()
    fmt.Println(obj2.GetCount())    
    obj3 := GetInstance()
    obj3.AddOne()
    fmt.Println(obj3.GetCount())
}

预期结果是：

1 2 3

因为您正在访问相同的资源。这就是我添加互斥锁的原因，以便能够从多个进程并发访问 count 属性。 :-)

来源：

https://play.golang.org/p/2XnLztX8Gs5

Answer 7

您可以使用 once 包 进行初始化：

这将确保您的 init 方法仅被调用一次。

Answer 8

只需拥有所需对象的单个静态、最终、常量、全局、应用程序范围实例即可。

然而，这与面向对象范式相矛盾。它的使用应仅限于基元和不可变对象，而不是可变对象。

Answer 9

您应该知道 Once.Do 非常重视只执行一次代码。这意味着，代码总是只执行一次，即使它可能已经恐慌：

来自 https://golang.org/pkg/sync/#Once.Do

如果f（注意：once逻辑）发生恐慌，Do认为它已经返回；以后调用 Do 返回而不调用 f。

我使用互斥体来确保全局配置变量的唯一初始化，以克服此限制：

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

Answer 10

我认为如果你想要 Go 中的单例之类的东西，你应该尝试思考你想要实现的目标。与 Java 或 C# 不同，Go 没有“静态”类的概念，因此传统的区别不太明确。在我看来，您希望从单例中获得的关键点是不允许其他人构建它。为此，我认为可以更简单地实现：导出一个接口，实现一个实现该接口的未导出类，然后导出它的单个实例。例如：

var DefaultTransformer Transformer = &transformer{}

type Transformer interface {
    Transform(s string) string
}

type transformer struct {
    
}

func (t *transformer) Transform(s string) string {
    return s + "1"
}

var _ Transformer = (*transformer)(nil)

正如其他答案所示，有很多更字面的方法可以在 Go 中实现单例模式，但它们让我觉得答案是从必须精确复制模式的前提开始的，而不是从解决实际的问题开始。你在 Go 中遇到的问题。