侧边栏壁纸
博主头像
汪洋

即使慢,驰而不息,纵会落后,纵会失败,但一定可以达到他所向的目标。 - 鲁迅

  • 累计撰写 190 篇文章
  • 累计创建 74 个标签
  • 累计收到 108 条评论

Go 实现常用设计模式 - 单例模式

汪洋
2023-02-28 / 0 评论 / 0 点赞 / 403 阅读 / 5,198 字

单例 (singleton)

意图

使程序运行期间只存在一个实例对象

前提

Go 标准库 —— sync.Mutex 互斥锁 - 点击跳转

代码演示

传统单例模式

package main

import (
	"fmt"
	"sync"
)

var (
	instance *Instance
	lock     sync.Mutex
)

type Instance struct {
	Name string
}

// 双重检查
func GetInstance(name string) *Instance {
	if instance == nil {
		lock.Lock()
		defer lock.Unlock()
		defer fmt.Println("istance func")
		if instance == nil {
			instance = &Instance{Name: name}
		}
	}
	return instance
}

func main() {
	test1 := GetInstance("wangyang")
	test2 := GetInstance("zhangsan")
	fmt.Println(test1.Name)
	fmt.Println(test2.Name)
	fmt.Println("main func")
}

wangyang@WangYangdeMacBook-Pro testcode % go run main.go
istance func
wangyang
wangyang
main func

Go 语言风格的单例模式

package main

import (
	"fmt"
	"sync"
)

var (
	goInstance *Instance
	once       sync.Once
)

type Instance struct {
	Name string
}

// 使用go 实现单例模式
func GoInstance(name string) *Instance {
	if goInstance == nil {
		once.Do(func() {
			goInstance = &Instance{
				Name: name,
			}
		})
	}
	return goInstance
}

func main() {
	test1 := GoInstance("wangyang")
	test2 := GoInstance("zhangsan")
	fmt.Println(test1.Name)
	fmt.Println(test2.Name)
}

来自 Go 语言单例模式的思考

并发经典场景

Go 并发编程的场景中,有一个特别经典的场景,就是并发创建对象的时候。一般伪代码如下:

if ( /* 如果对象不存在 */) {
    // 那么就创建对象 
}

因为是并发的环境,所以多个 goroutine 短时间内得出的判断都是一样的:都判断得到对象是不存在的,这时候大家的的行为也特别一致,每个 goroutine 磨刀霍霍就是创建。这时候如果不加以控制,那么会导致程序逻辑出问题。会导致对象重复创建多次,并且可能不断的被替换和丢弃。

怎么解决

加锁互斥

最简单的方法:加锁互斥。保证判断和创建这两个动作是原子操作,这样就不存在并发误判的时间窗,那么就不会存在以上问题了

lock ...
{
    if ( /* 如果对象不存在 */) {
        // 那么就创建对象 
    }
}
unlock ...

加锁不可怕,锁冲突才可怕,如果每次都要抢一把锁,那性能就划不来了

Once

在 Go 的并发库对此有另外一个实现:sync.Once 对象。这是一个非常小巧的实现,对象实现代码极其精简。这个库非常方便的实现 Go 的单实例设计模式。我们换一个思路,我们不做判断,需要一个库能够提供只执行一次的语义,那么也能实现我们的目的。没错,就是直接调用 Once.Do 执行创建对象,业务方甚至都不需要再做多余的判断的动作,如下:

once.Do(/* 创建对象 */)

对,就是这么简单,上面的调用就能保证在并发的上下文中,保持正确性。那么 sync.Once 对外保证了什么语义呢?

划重点:确保传入函数只被执行一次。

这里注意思考一个点:只执行一次是针对库的还是针对实例的?

划重点:只执行一次的语义是和具体的 once 变量绑定的。

怎么理解?举个例子

var once1 sync.Once
var once2 sync.Once

once1.Do( f1 )
once2.Do( f2 )

f1 和 f2 各保证执行一次

单例实现

单例模式模式可以说是设计模式里最简单的了。Go 怎么实现只创建一个对象呢?

非常简单,就是借助 sync.Once 结构。举个完整的例子:

package main

import (
	"fmt"
	"sync"
)

type SomeObject struct {
	Name string
}

// 全局变量(我们只希望创建一个)
var s *SomeObject

// 定义一个 once 变量
var once sync.Once

// 只希望创建一个,单例模式
func GetInstance(name string ) *SomeObject {
	once.Do(func(){
		// 创建一个对象,赋值指针给全局变量
		s = &SomeObject{
			Name: name,
		}
	})
	return s
}

func main(){
	t1 := GetInstance("wangyang")
	fmt.Println((*t1).Name)
	t2 := GetInstance("lisi")
	fmt.Println((*t2).Name)
}

wangyang@WangYangdeMacBook-Pro testcode % go run main.go 
wangyang
wangyang

这样,我们就实现了单例模式,每次调用 GetInstance 函数返回的对象都只有一个。那么 sync.Once 是怎么做到的呢?

Once 的实现

以下就是 Once 实例的全部源码实现,非常的简短,也非常的有趣

package sync

import (
    "sync/atomic"
)

type Once struct {
    done uint32
    m    Mutex
}

func (o *Once) Do(f func()) {
    // 思考题:为什么这里不用 cas 来判断?
    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 来加计数?
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

以上的 sync.Once 实现非常简短,但是也有两个值得思考的地方。

  • 为什么 Once.Do 里面没有用 cas 判断?原子操作岂不是更快?
  • 为什么 Once.doSlow 里面用 defer 来加计数,而不是直接操作?

思考:为什么没有用 cas 原子判断?

什么是 cas ?

Go 里面有是 atomic.CompareAndSwapUint32 实现这 cas 的功能。 cas 就是 Compare And Swap 的缩写,把判断和赋值包装成一个原子操作。我们看一下 cas 的伪代码实现:

func cas(p : pointer to int, old : int, new : int) bool {
    // *p 不等于 old 的时候,返回 false
    if *p != old {
        return false
    }
    // *p 等于 old 的时候,赋值新值,并返回 true
    *p = new
    return true
}

上面的就是 cas 的伪代码实现,cas 保证上面的逻辑是原子操作。思考下,为什么 Once 不能用如下的实现:

if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
    f()
}

第一眼看过去,好像也能实现 Once 只执行一次语义?

这个代码看起来 o.done == 0 的时候,会赋值 o.done==1,然后执行 f()。其他并发请求的时候, o.done == 1,就不会再进到这个分支里,貌似也可以?

那为什么没用原子操作呢?cas 原子操作不是性能最好的吗?

细品下,虽然能保证只执行一次,却有个致命的缺陷:无法在 o.done==1 的时候保证 f() 还没有执行完成。Golang 的标准库也针对这些提到了这点。

// Do guarantees that when it returns, f has finished.
// This implementation would not implement that guarantee:
// given two simultaneous calls, the winner of the cas would
// call f, and the second would return immediately, without
// waiting for the first's call to f to complete.

当 o.done 判断为 0 的时候,立即就设置成了 1 ,这个时候才走到 f() 函数里执行,这里的语义不再正确。

Once 不仅要保证只执行一次,还要保证当其他用户看到 o.done==1 导致 Once.Do 返回的时候,确保执行完成。

这个语义很重要吗?

非常重要,这里涉及到逻辑的正确性。举个栗子,我们用 Once.Do 来创建一个唯一的全局变量对象,如果是你回复了用户已经 Once.Do 成功,但是却 f() 还在执行过程,那么就会出现中间态,全局变量还没有创建出来,行为是无法定义的。

那么怎么解决?解决非常简单,两个思路:

  • 热路径:用原子读 o.done 的值,保证竞态条件正确;
  • 既然不能用 cas 原子操作,那就用锁机制来保证原子性。如果 o.done == 0 ,那么就走慢路径,
    • 注意:以下所有逻辑在一把大锁内
    • 先执行 f() 函数;
    • 然后才去设置 o.done 为 1;

第一次可能在锁互斥的时候,可能会比较慢。因为要抢锁,但是只要执行过一次,就不会在走到锁内的逻辑了。都是走原子读的路径,也是非常快的。

既然提到锁,我们再来看一个死锁的例子。Once 内部用锁来保证代码的临界区,那么就千万不要嵌套使用,不然会死锁。如下:

once1.Do( func(){
    once1.Do( func(){
        /* something */
    } )
} )

上面的代码会死锁在 once1.m.Lock() 的调用上。

划重点:千万不要把 sync.Once 用的复杂,要保持简洁,嵌套很容易死锁。

思考:为什么 doSlow 用 defer 来加计数,而不是 f() 之后直接操作?

Once.doSlow 整个是在锁内操作的,所以这段代码的操作是串行化的。如果 o.done 为 0,标识没有执行过 f,整个时候注册一个 defer 函数 defer atomic.StoreUint32(&o.done, 1) ,然后运行 f()

func (o *Once) doSlow(f func()) {
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        // 思考题:为什么这里用 defer 来加计数?
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

这里为什么要用 defer 来确保执行 o.done 赋值为 1 的操作呢?踏实把 atomic.StoreUint32(&o.done, 1) 放到 f() 之后不好吗?

不好!因为处理不了 panic 的异常。举个例子:

如果不用 defer ,当 f() 执行的时候出现 panic 的时候(被外层 recover,进程没挂),会导致没有 o.done 加计数,但其实 f() 已经执行过了,这就违反语义了。

之前我们说过,defer 注册的函数,就算 f() 内部执行出现 panic ,也会被执行,所以这里就保证了 Once 对外的语义:执行过一次,o.done 一定是非 0。

不过,我们继续思考 panic 场景,如果说 f() 因为某些原因,导致了 panic,可能并没有执行完,这种时候,也再不会执行 Once.Do 了,因为已经执行过一次了。业务自己承担这个责任,框架已经尽力了。

Once 的语义

这里归纳出 Once 提供的语义:

  • Once.Do 保证只调用一次的语义,无论 f() 内部有没有执行完( panic );
  • 只有 f() 执行完成,Once.Do 才会返回,否则阻塞等待 f() 的第一次执行完成;

抢锁简要演示:

总结

  • Once 对外提供 f() 只调用一次的语义;
  • Once.Do 返回之后,按照约定,f() 一定被执行过一次,并且只执行过一次。如果没有执行完,会阻塞等待 f() 的第一次执行完成;
  • Once 只执行一次的语义是跟实例绑定的关系,多个 Once 实例的话,每个实例都有一次的机会;
  • 内部用锁机制来保证逻辑的原子性,先执行 f() ,然后设置 o.done 标识位;
  • Once 用 defer 机制保证 panic 的场景,也能够保证 o.done 标识位被设置;
  • Once 实例千万注意,不要嵌套,内部有锁,乱用的话容易死锁;
0

评论区