Golang的sync包--sync.Once

  1. sync.Once:sync包是golang提供的一个线程安全的同步包,once一次,once提供的Do方法中的f只会被调用一次,简便f出现了panic,再次调用once的Do方法,f也不会被执行

  2. sync.Once使用示例

func main() {
	once := sync.Once{}
	for i := 0; i < 5; i++ {
		once.Do(doSomething)
		time.Sleep(time.Second)
	}
	fmt.Println("end")
}

func doSomething() {
	fmt.Printf("do it, time_stamp:%d\n", time.Now().Unix())
}

输出结果:

do it, time_stamp:1559812858
end

once.Do被执行了5次,但是只有一个输出,也就是doSomething只被执行了一次,这样让我们很好的联想到了单例模式,多次执行只会创建一个对象

  1. 使用sync.Once实现单例模式
func main() {
	//启动多个协程获取对象并且调用对象的打印内存地址的方法
	for i := 0; i < 5; i++ {
		go func() {
			singleton := GetSingleton()
			singleton.PrintAddress()
		}()
	}
	//睡眠一下,避免go程未执行就终止了程序
	time.Sleep(time.Second)
}

type singleton struct {
}

var st *singleton
var once sync.Once

//获取对象实例
func GetSingleton() *singleton {
	if st != nil {
		return st
	}
	once.Do(func() {
		//模拟对象创建耗时操作
		time.Sleep(time.Millisecond*10)
		st = &singleton{}
	})
	return st
}

//打印内存地址
func (s *singleton) PrintAddress() {
	fmt.Printf("%p \n", s)
}

输出结果:

0x59a1c8 
0x59a1c8 
0x59a1c8 
0x59a1c8 
0x59a1c8 

输出结果都是一样的,对象的内存地址都一样,所以对象都是同一个,对象没有被重复创建。使用sync.Once很优雅的实现了单例模式,无需自己进行加锁等操作

4.源码分析

type Once struct {
	m    Mutex  //互斥锁
	done uint32 //f方法的执行标识,0未执行,1已执行
}

func (o *Once) Do(f func()) {
 	//done==1,表示f已经被执行了,直接返回
	if atomic.LoadUint32(&o.done) == 1 {
		return
	}
	
	//加锁
	o.m.Lock()
	//使用defer释放锁
	defer o.m.Unlock()
	
	//再次判断done是否已经执行,done==0表示未执行,双重校验,避免f多次执行
	if o.done == 0 {
		//执行f方法,执行完成后,done置为1,
		//因为使用defer将done置为1,所以即便是f中panic了,done也会被置为1
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

5.小结
如果我们的代码中需要某部分代码只被执行一次,可以使用sync.once优雅的去实现。比如:程序启动时,初始化配置文件解析到对象当中,抑或着是使用单例模式都可以使用once很好的实现。

<think>嗯,用户问的是Go语言中的sync.Once怎么使用。我需要先回忆一下sync.Once的基本概念和用途。记得sync.Once是用来确保某个操作只执行一次,不管有多少个goroutine调用它。这在单例模式或者初始化配置时很有用。 首先,我应该解释一下sync.Once的作用,让用户明白为什么需要这个结构。然后,可能需要举一个例子,说明如何声明和使用它。比如,用Do方法裹初始化函数,确保只运行一次。 然后,用户可能想知道具体的用法步骤,比如声明一个sync.Once变量,然后在需要的地方调用Do方法,传入要执行的函数。需要注意的是,传入的函数不能带参数,所以如果有参数的话,可能需要用闭或者封装一下。 接下来,应该举一个实际的代码示例,展示如何在实际中使用sync.Once。比如初始化一个数据库连接或者配置文件,确保多个goroutine同时调用时,初始化只执行一次。这时候,可能需要用一些变量来存储初始化后的结果,比如全局变量或者结构体中的字段。 另外,需要提醒用户一些注意事项,比如传入的函数如果有不同的逻辑,可能会导致多次执行,因为sync.Once是根据实例来判断的。所以每个不同的操作需要单独的sync.Once实例。另外,错误处理的问题,如果在Do中的函数执行失败,再次调用Do时不会重试,所以需要内部处理错误,或者记录错误状态。 可能还需要提到sync.Once的内部实现原理,比如使用原子操作和互斥锁来保证并发安全,这样用户能更好地理解其高效性。但不需要太深入,点到为止即可。 用户可能会有疑问,如果有多个不同的初始化函数,应该怎么处理。这时候需要说明每个初始化函数都需要自己的sync.Once实例。比如,初始化配置和初始化数据库连接应该分别使用不同的sync.Once变量。 另外,错误处理是一个重要的点,如果在Do里面的函数返回了错误,用户可能想知道怎么处理这种情况。这时候应该建议在函数内部处理错误,或者设置一个全局的错误变量,在调用Do之后检查是否有错误发生。 总结一下,回答的结构应该是先介绍用途,然后基本用法,接着代码示例,再是注意事项,最后可能加上内部原理的简要说明。这样用户能够逐步理解并正确使用sync.Once。</think>### 一、sync.Once 的作用 `sync.Once` 是 Go 语言标准库中用于 **保证某个操作仅执行一次** 的并发安全工具。典型场景括: - 单例模式(如数据库连接池初始化) - 延迟初始化(按需加载配置) - 避免重复计算 --- ### 二、基础用法 #### 1. 声明与调用 ```go var once sync.Once // 需要保证只执行一次的函数 initFunc := func() { fmt.Println("This runs only once") } // 在多个 goroutine 中调用 once.Do(initFunc) ``` #### 2. 完整示例 ```go package main import ( "fmt" "sync" ) var ( config map[string]string once sync.Once ) func loadConfig() { fmt.Println("Loading config...") config = map[string]string{"env": "prod", "timeout": "30s"} } func GetConfig() map[string]string { once.Do(loadConfig) // 并发安全初始化 return config } func main() { // 启动多个 goroutine 测试 var wg sync.WaitGroup for i := 0; i < 5; i++ { wg.Add(1) go func() { defer wg.Done() fmt.Println(GetConfig()) // 只有第一次会触发 loadConfig() }() } wg.Wait() } ``` 输出: ``` Loading config... map[env:prod timeout:30s] map[env:prod timeout:30s] map[env:prod timeout:30s] map[env:prod timeout:30s] map[env:prod timeout:30s] ``` --- ### 三、关键注意事项 #### 1. 函数无参数 通过闭解决参数传递问题: ```go var ( dbConn string dbOnce sync.Once ) func InitDB(host string) { dbOnce.Do(func() { // 使用闭传递参数 dbConn = fmt.Sprintf("connect to %s", host) }) } ``` #### 2. 错误处理 若初始化可能出错,建议内部记录错误状态: ```go var ( cache map[string]int once sync.Once initErr error ) func initCache() { defer func() { if r := recover(); r != nil { initErr = fmt.Errorf("init failed: %v", r) } }() // 可能出错的操作 cache = make(map[string]int) cache["key"] = 1 / 0 // 模拟 panic } func GetCache() (map[string]int, error) { once.Do(initCache) return cache, initErr } ``` #### 3. 不同操作需独立实例 ```go var ( onceA sync.Once onceB sync.Once ) func InitA() { onceA.Do(/* ... */) } func InitB() { onceB.Do(/* ... */) } // 需使用不同的 Once 实例 ``` --- ### 四、实现原理 `sync.Once` 通过 `uint32` 原子标志位 + 互斥锁实现: 1. 原子操作检查标志位 `done` 2. 首次执行时加锁运行函数 3. 后续调用直接返回 源码关键片段: ```go type Once struct { done uint32 m Mutex } func (o *Once) Do(f func()) { if atomic.LoadUint32(&o.done) == 0 { o.doSlow(f) } } func (o *Once) doSlow(f func()) { o.m.Lock() defer o.m.Unlock() if o.done == 0 { defer atomic.StoreUint32(&o.done, 1) f() } } ``` --- ### 五、典型应用场景 1. 全局配置加载 2. 数据库连接池初始化 3. 文件系统单次检查 4. 日志处理器设置 --- ### 六、性能建议 - 高频调用场景下性能优异(原子操作消耗极小) - 避免在 `Do` 中执行耗时操作(会阻塞后续调用) - 对需要重置的场景,建议重新创建实例而非修改 `done` 标志
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值