从一本登记簿理解 Go 单例模式:为什么两次获取,拿到的是同一个对象?

1 阅读6分钟

刚开始学习单例模式时,我最困惑的不是“单例”这个名字,而是这句话:

让多个地方使用同一个对象,并确保它只初始化一次。

“同一个对象”到底体现在哪里?代码中的指针又起了什么作用?

后来,我用“一家店共用一本登记簿”的例子,逐渐理解了它。

一、先从生活中的登记簿说起

假设店里的前台和仓库需要记录包裹信息。

如果他们各自新建一本登记簿:

前台 → 登记簿 A:收到一个包裹

仓库 → 登记簿 B:没有记录

仓库翻开自己的登记簿,看不到前台写的内容。

如果规定大家都通过同一个入口获取店里的登记簿:

前台 ──┐
       ├──→ 同一本登记簿
仓库 ──┘

前台写入记录后,仓库就能看到。

单例模式的目标,就是让程序中的多个地方,通过约定的入口取得同一个实例。

二、What:单例模式是什么?

理解单例,可以抓住两个特征:

  1. 初始化只执行一次。
  2. 后续每次获取,都返回已经保存的那个实例。

普通创建函数可能每次都创建新对象:

func NewLogBook() *LogBook {
	return &LogBook{}
}

而单例的获取函数需要记住:是否已经创建过?如果创建过,就返回原来的对象。

Go 中可以使用 sync.Once,让初始化代码只执行一次,即使多个 goroutine 同时调用也可以。

三、How:用 Go 写一本共享登记簿

创建 main.go,输入下面的代码:

package main

import (
	"fmt"
	"sync"
)

// LogBook 表示登记簿。
type LogBook struct {
	Notes []string
}

// once 控制初始化只执行一次。
// book 保存那本登记簿的地址。
var (
	once sync.Once
	book *LogBook
)

// GetLogBook 返回共享的登记簿。
func GetLogBook() *LogBook {
	once.Do(func() {
		fmt.Println("创建了一本登记簿")
		book = &LogBook{}
	})

	return book
}

func frontDesk() {
	b := GetLogBook()

	b.Notes = append(b.Notes, "前台:收到一个包裹")

	fmt.Printf("前台拿到的地址:%p\n", b)
}

func warehouse() {
	b := GetLogBook()

	fmt.Printf("仓库拿到的地址:%p\n", b)
	fmt.Println("仓库看到的记录:", b.Notes)
}

func main() {
	frontDesk()
	warehouse()
}

这段代码按顺序调用前台和仓库,用于观察共享对象的效果。

在文件所在目录运行:

go run main.go

输出大致如下,地址的具体数字可能不同:

创建了一本登记簿
前台拿到的地址:0x1400000a018
仓库拿到的地址:0x1400000a018
仓库看到的记录: [前台:收到一个包裹]

单例的特征,就体现在这三个结果里:

  • 创建提示只出现一次:初始化只执行了一次。
  • 两次打印的地址相同:拿到的指针指向同一个对象。
  • 仓库读到了前台写的记录:两处使用的是同一份数据。

四、指针在这里起什么作用?

这是我学习时最需要慢慢理解的部分。

*LogBook:用来保存登记簿的地址

var book *LogBook

这里声明了一个变量 book,它的类型是“指向 LogBook 的指针”。

可以先把指针理解为:通过这个地址,可以找到内存中的那个对象。

刚声明时,book 的值是 nil,还没有指向登记簿。

&LogBook{}:创建登记簿,并取得它的地址

book = &LogBook{}

这行代码创建一个 LogBook,把它的地址保存到 book 中。

return book:把保存的地址交给调用者

a := GetLogBook()
b := GetLogBook()

a 和 b 是两个变量,但它们保存的是同一个地址:

变量 a ──┐
         ├──→ 内存中的同一个 LogBook
变量 b ──┘

因此,通过 a 修改登记簿,通过 b 就能看到修改后的内容。

单例并不要求程序里只能有一个变量,而是这些获取到的变量都指向同一个实例。

五、sync.Once 到底做了什么?

回头看获取函数:

func GetLogBook() *LogBook {
	once.Do(func() {
		fmt.Println("创建了一本登记簿")
		book = &LogBook{}
	})

	return book
}

第一次调用时:

调用 GetLogBook
    ↓
执行 once.Do 中的初始化代码
    ↓
创建登记簿,保存地址
    ↓
返回地址

第二次及以后的调用:

调用 GetLogBook
    ↓
初始化代码已经执行过
    ↓
返回之前保存的地址

要注意,once 放在包级变量中,所有调用共享同一个 sync.Once。如果每次进入函数都重新创建一个局部的 sync.Once,就无法实现这个目的。

在这个例子中,我们约定通过 GetLogBook 获取共享登记簿。直接在其他地方写 &LogBook{},仍然可以创建额外对象;Go 不会因为存在获取函数,就自动禁止其他创建方式。

六、写一个测试验证它

在 main.go 同一目录下创建 main_test.go:

package main

import "testing"

func TestGetLogBook(t *testing.T) {
	a := GetLogBook()
	b := GetLogBook()

	// 验证两次获取指向同一个对象。
	if a != b {
		t.Fatal("两次获取应该返回同一个登记簿")
	}

	// 保存原始记录,测试结束后恢复。
	oldNotes := a.Notes
	t.Cleanup(func() {
		a.Notes = oldNotes
	})

	// 验证通过一处写入,可以从另一处读到。
	a.Notes = []string{"测试:收到一个包裹"}

	if len(b.Notes) != 1 {
		t.Fatal("另一处没有读到共享记录")
	}

	if b.Notes[0] != "测试:收到一个包裹" {
		t.Fatal("读取到的内容不正确")
	}
}

如果还没有初始化 Go 模块,先在练习目录执行一次:

go mod init singleton-demo

然后运行:

go test -v .

这里的测试按顺序运行,用来验证“同一个实例”和“共享数据”两个特征。

七、Where:单例适合用在哪里?

需要在一个进程内共享某个实例、并且只初始化一次时,可以考虑这种方式。例如:

场景共享的内容
应用配置启动时加载的一份配置
进程内缓存多个功能共同访问的缓存对象
数据库连接池创建后供多个业务功能复用的连接池

需要区分的是:一个连接池对象,内部可以管理多个数据库连接。 单例并不意味着数据库只能有一条连接。

八、Why:为什么不能到处使用单例?

单例方便共享,也会带来约束。

第一,共享对象的修改需要另外考虑并发安全。

sync.Once 只保证初始化执行一次。上面的 Notes 如果被多个 goroutine 同时读写,仍需要锁等同步措施。登记簿“只创建一本”和“多人同时写也不会出问题”,是两件事。

第二,单例通常只在当前进程内生效。

启动两个服务进程,它们各自拥有自己的内存,也就各自有一个实例。单例不能让两台服务器自动共享同一份数据。

第三,全局共享会让测试和依赖替换变得困难。

例如,业务代码直接调用全局获取函数,测试时就可能难以替换成另一份配置或模拟实现。对于很多业务依赖,在程序入口创建一次,再通过参数传给需要它的模块,也是一种清楚的做法。

学习单例后,我会先问自己:

如果这里创建两个实例,会出现什么实际问题?

如果没有问题,就不必强制只能创建一个。真正需要单例时,再检查它的两个特征:初始化只执行一次,后续获取返回同一个实例。

23:09