关于golang:手动实现synconce

介绍

sync.Once 是一个简略而且弱小的同步原语，应用它能够保障援用的函数只执行一次，常常在初始化配置时候用到该同步原语。

就它的用法看一个示例：

func main() {
 var once sync.Once
 for i := 0;i < 10;i++{go func() {once.Do(func() {fmt.Println("once 内")
 })
 }()}
 time.Sleep(time.Second*5)
}
/*
输入后果：once 内
*/

能够看到，在并发状况下，该函数只执行了一次。当然，在非并发状况下同样保障只执行一次。

实现

接下来咱们依据这个需要应用 channel 本人入手实现一个 once。

首先定义构造体：

type OnceBak struct {c chan int _// 通过接管的 channel 值来判断是否执行过办法_}

申明一个构造函数：

func NewOnce() *OnceBak {
 // 结构一个有缓冲的通道，避免 deadlock 谬误
 ch := make(chan int,1)
 // 在 channel 发送一个数字 1 作为标记位
 ch <- 1
 return &OnceBak{c: ch,}
}

该构造体实现了一个 Do 办法，入参是一个函数：

func (o *OnceBak) Do(f func()) { 
 i := <- o.c 
 // 判断接管到的是否为 1，能够晓得该办法是否执行过 
 if i == 1{ 
 // 执行入参函数
 f() 
 // 敞开 channel 的作用 
 // 1，避免 channel 读不到数据产生阻塞 
 //2, 从敞开的管道里读到的 int 类型的默认值 0 
 close(o.c) 
 }
}

来做一个小试验测试一下是否合乎预期：

func main() {once := syn.NewOnce()
 for i := 0;i < 5;i++{go func() {once.Do(func() {fmt.Println("once 中办法.....")
 })
 fmt.Println("once 外办法 -------")
 }()}
 time.Sleep(time.Second)
}
/*
测试后果：once 中办法.....
once 外办法 -------
once 外办法 -------
once 外办法 -------
once 外办法 -------
once 外办法 -------
*/

能够看到根本满足预期，Do 办法里的函数只执行了一次，里面的办法仍旧失常执行。

源码

源码中的 sync.once 也较为简单，贴出来浏览一下：

type Once struct { 
    done uint32 // 标记位
    m Mutex // 保障原子操作
}
/*
判断一下 Once 中的 done 标记位是不是默认值 0
这里应用的 atomic 包保障了原子操作
*/
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()}
}

留神

留神，应用该原语要留神的是，该原语只保障 sync.Once 只计算 Do 被调用的次数，而不是调用传入 Do 的参数的次数，举个例子：

func main()  {
 var once sync.Once
 f1 := func() {fmt.Println("我是 f1")}
 f2 := func() {fmt.Println("我是 f2")}
 for i := 0;i < 10;i++{once.Do(f1)
 once.Do(f2)
 }
}
/*
该函数的输入后果是：我是 f1
*/

本次分享完结，持续享受残余的假期。