刚开始学习单例模式时,我最困惑的不是“单例”这个名字,而是这句话:
让多个地方使用同一个对象,并确保它只初始化一次。
“同一个对象”到底体现在哪里?代码中的指针又起了什么作用?
后来,我用“一家店共用一本登记簿”的例子,逐渐理解了它。
一、先从生活中的登记簿说起
假设店里的前台和仓库需要记录包裹信息。
如果他们各自新建一本登记簿:
前台 → 登记簿 A:收到一个包裹
仓库 → 登记簿 B:没有记录
仓库翻开自己的登记簿,看不到前台写的内容。
如果规定大家都通过同一个入口获取店里的登记簿:
前台 ──┐
├──→ 同一本登记簿
仓库 ──┘
前台写入记录后,仓库就能看到。
单例模式的目标,就是让程序中的多个地方,通过约定的入口取得同一个实例。
二、What:单例模式是什么?
理解单例,可以抓住两个特征:
- 初始化只执行一次。
- 后续每次获取,都返回已经保存的那个实例。
普通创建函数可能每次都创建新对象:
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