资讯专栏INFORMATION COLUMN

Go语言核心36讲(Go语言实战与应用十二)--学习笔记

不知名网友 / 3523人阅读

摘要:除此之外,把并发安全字典封装在一个结构体类型中,往往是一个很好的选择。请看下面的代码如上所示,我编写了一个名为的结构体类型,它代表了键类型为值类型为的并发安全字典。在这个结构体类型中,只有一个类型的字段。

34 | 并发安全字典sync.Map (上)

我们今天再来讲一个并发安全的高级数据结构:sync.Map。众所周知,Go 语言自带的字典类型map并不是并发安全的。

前导知识:并发安全字典诞生史

换句话说,在同一时间段内,让不同 goroutine 中的代码,对同一个字典进行读写操作是不安全的。字典值本身可能会因这些操作而产生混乱,相关的程序也可能会因此发生不可预知的问题。

在sync.Map出现之前,我们如果要实现并发安全的字典,就只能自行构建。不过,这其实也不是什么麻烦事,使用 sync.Mutex或sync.RWMutex,再加上原生的map就可以轻松地做到。

GitHub 网站上已经有很多库提供了类似的数据结构。我在《Go 并发编程实战》的第 2 版中也提供了一个比较完整的并发安全字典的实现。它的性能比同类的数据结构还要好一些,因为它在很大程度上有效地避免了对锁的依赖。

尽管已经有了不少的参考实现,Go 语言爱好者们还是希望 Go 语言官方能够发布一个标准的并发安全字典。

经过大家多年的建议和吐槽,Go 语言官方终于在 2017 年发布的 Go 1.9 中,正式加入了并发安全的字典类型sync.Map。

这个字典类型提供了一些常用的键值存取操作方法,并保证了这些操作的并发安全。同时,它的存、取、删等操作都可以基本保证在常数时间内执行完毕。换句话说,它们的算法复杂度与map类型一样都是O(1)的。

在有些时候,与单纯使用原生map和互斥锁的方案相比,使用sync.Map可以显著地减少锁的争用。sync.Map本身虽然也用到了锁,但是,它其实在尽可能地避免使用锁。

我们都知道,使用锁就意味着要把一些并发的操作强制串行化。这往往会降低程序的性能,尤其是在计算机拥有多个 CPU 核心的情况下。

因此,我们常说,能用原子操作就不要用锁,不过这很有局限性,毕竟原子只能对一些基本的数据类型提供支持。

无论在何种场景下使用sync.Map,我们都需要注意,与原生map明显不同,它只是 Go 语言标准库中的一员,而不是语言层面的东西。也正因为这一点,Go 语言的编译器并不会对它的键和值,进行特殊的类型检查。

如果你看过sync.Map的文档或者实际使用过它,那么就一定会知道,它所有的方法涉及的键和值的类型都是interface{},也就是空接口,这意味着可以包罗万象。所以,我们必须在程序中自行保证它的键类型和值类型的正确性。

好了,现在第一个问题来了。今天的问题是:并发安全字典对键的类型有要求吗?

这道题的典型回答是:有要求。键的实际类型不能是函数类型、字典类型和切片类型。

解析一下这个问题。 我们都知道,Go 语言的原生字典的键类型不能是函数类型、字典类型和切片类型。

由于并发安全字典内部使用的存储介质正是原生字典,又因为它使用的原生字典键类型也是可以包罗万象的interface{};所以,我们绝对不能带着任何实际类型为函数类型、字典类型或切片类型的键值去操作并发安全字典。

由于这些键值的实际类型只有在程序运行期间才能够确定,所以 Go 语言编译器是无法在编译期对它们进行检查的,不正确的键值实际类型肯定会引发 panic。

因此,我们在这里首先要做的一件事就是:一定不要违反上述规则。我们应该在每次操作并发安全字典的时候,都去显式地检查键值的实际类型。无论是存、取还是删,都应该如此。

当然,更好的做法是,把针对同一个并发安全字典的这几种操作都集中起来,然后统一地编写检查代码。除此之外,把并发安全字典封装在一个结构体类型中,往往是一个很好的选择。

总之,我们必须保证键的类型是可比较的(或者说可判等的)。如果你实在拿不准,那么可以先通过调用reflect.TypeOf函数得到一个键值对应的反射类型值(即:reflect.Type类型的值),然后再调用这个值的Comparable方法,得到确切的判断结果。

知识扩展

问题 1:怎样保证并发安全字典中的键和值的类型正确性?(方案一)

简单地说,可以使用类型断言表达式或者反射操作来保证它们的类型正确性。

为了进一步明确并发安全字典中键值的实际类型,这里大致有两种方案可选。

第一种方案是,让并发安全字典只能存储某个特定类型的键。

比如,指定这里的键只能是int类型的,或者只能是字符串,又或是某类结构体。一旦完全确定了键的类型,你就可以在进行存、取、删操作的时候,使用类型断言表达式去对键的类型做检查了。

一般情况下,这种检查并不繁琐。而且,你要是把并发安全字典封装在一个结构体类型里面,那就更加方便了。你这时完全可以让 Go 语言编译器帮助你做类型检查。请看下面的代码:

</>复制代码

  1. type IntStrMap struct { m sync.Map}func (iMap *IntStrMap) Delete(key int) { iMap.m.Delete(key)}func (iMap *IntStrMap) Load(key int) (value string, ok bool) { v, ok := iMap.m.Load(key) if v != nil { value = v.(string) } return}func (iMap *IntStrMap) LoadOrStore(key int, value string) (actual string, loaded bool) { a, loaded := iMap.m.LoadOrStore(key, value) actual = a.(string) return}func (iMap *IntStrMap) Range(f func(key int, value string) bool) { f1 := func(key, value interface{}) bool { return f(key.(int), value.(string)) } iMap.m.Range(f1)}func (iMap *IntStrMap) Store(key int, value string) { iMap.m.Store(key, value)}

如上所示,我编写了一个名为IntStrMap的结构体类型,它代表了键类型为int、值类型为string的并发安全字典。在这个结构体类型中,只有一个sync.Map类型的字段m。并且,这个类型拥有的所有方法,都与sync.Map类型的方法非常类似。

两者对应的方法名称完全一致,方法签名也非常相似,只不过,与键和值相关的那些参数和结果的类型不同而已。在IntStrMap类型的方法签名中,明确了键的类型为int,且值的类型为string。

显然,这些方法在接受键和值的时候,就不用再做类型检查了。另外,这些方法在从m中取出键和值的时候,完全不用担心它们的类型会不正确,因为它的正确性在当初存入的时候,就已经由 Go 语言编译器保证了。

稍微总结一下。第一种方案适用于我们可以完全确定键和值的具体类型的情况。在这种情况下,我们可以利用 Go 语言编译器去做类型检查,并用类型断言表达式作为辅助,就像IntStrMap那样。

总结

我们今天讨论的是sync.Map类型,它是一种并发安全的字典。它提供了一些常用的键、值存取操作方法,并保证了这些操作的并发安全。同时,它还保证了存、取、删等操作的常数级执行时间。

与原生的字典相同,并发安全字典对键的类型也是有要求的。它们同样不能是函数类型、字典类型和切片类型。

另外,由于并发安全字典提供的方法涉及的键和值的类型都是interface{},所以我们在调用这些方法的时候,往往还需要对键和值的实际类型进行检查。

这里大致有两个方案。我们今天主要提到了第一种方案,这是在编码时就完全确定键和值的类型,然后利用 Go 语言的编译器帮我们做检查。

在下一次的文章中,我们会提到另外一种方案,并对比这两种方案的优劣。除此之外,我会继续探讨并发安全字典的相关问题。

</>复制代码

  1. package mainimport (
  2. "fmt"
  3. "sync")// ConcurrentMap 代表自制的简易并发安全字典。type ConcurrentMap struct {
  4. m map[interface{}]interface{}
  5. mu sync.RWMutex}func NewConcurrentMap() *ConcurrentMap {
  6. return &ConcurrentMap{
  7. m: make(map[interface{}]interface{}),
  8. }}func (cMap *ConcurrentMap) Delete(key interface{}) {
  9. cMap.mu.Lock()
  10. defer cMap.mu.Unlock()
  11. delete(cMap.m, key)}func (cMap *ConcurrentMap) Load(key interface{}) (value interface{}, ok bool) {
  12. cMap.mu.RLock()
  13. defer cMap.mu.RUnlock()
  14. value, ok = cMap.m[key]
  15. return}func (cMap *ConcurrentMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
  16. cMap.mu.Lock()
  17. defer cMap.mu.Unlock()
  18. actual, loaded = cMap.m[key]
  19. if loaded {
  20. return
  21. }
  22. cMap.m[key] = value
  23. actual = value
  24. return}func (cMap *ConcurrentMap) Range(f func(key, value interface{}) bool) {
  25. cMap.mu.RLock()
  26. defer cMap.mu.RUnlock()
  27. for k, v := range cMap.m {
  28. if !f(k, v) {
  29. break
  30. }
  31. }}func (cMap *ConcurrentMap) Store(key, value interface{}) {
  32. cMap.mu.Lock()
  33. defer cMap.mu.Unlock()
  34. cMap.m[key] = value}func main() {
  35. pairs := []struct {
  36. k int
  37. v string
  38. }{
  39. {k: 1, v: "a"},
  40. {k: 2, v: "b"},
  41. {k: 3, v: "c"},
  42. {k: 4, v: "d"},
  43. }
  44. // 示例1。
  45. {
  46. cMap := NewConcurrentMap()
  47. cMap.Store(pairs[0].k, pairs[0].v)
  48. cMap.Store(pairs[1].k, pairs[1].v)
  49. cMap.Store(pairs[2].k, pairs[2].v)
  50. fmt.Println("[Three pairs have been stored in the ConcurrentMap instance]")
  51. cMap.Range(func(key, value interface{}) bool {
  52. fmt.Printf("The result of an iteration in Range: %v, %v/n",
  53. key, value)
  54. return true
  55. })
  56. k0 := pairs[0].k
  57. v0, ok := cMap.Load(k0)
  58. fmt.Printf("The result of Load: %v, %v (key: %v)/n",
  59. v0, ok, k0)
  60. k3 := pairs[3].k
  61. v3, ok := cMap.Load(k3)
  62. fmt.Printf("The result of Load: %v, %v (key: %v)/n",
  63. v3, ok, k3)
  64. k2, v2 := pairs[2].k, pairs[2].v
  65. actual2, loaded2 := cMap.LoadOrStore(k2, v2)
  66. fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",
  67. actual2, loaded2, k2, v2)
  68. v3 = pairs[3].v
  69. actual3, loaded3 := cMap.LoadOrStore(k3, v3)
  70. fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",
  71. actual3, loaded3, k3, v3)
  72. k1 := pairs[1].k
  73. cMap.Delete(k1)
  74. fmt.Printf("[The pair with the key of %v has been removed from the ConcurrentMap instance]/n",
  75. k1)
  76. v1, ok := cMap.Load(k1)
  77. fmt.Printf("The result of Load: %v, %v (key: %v)/n",
  78. v1, ok, k1)
  79. v1 = pairs[1].v
  80. actual1, loaded1 := cMap.LoadOrStore(k1, v1)
  81. fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",
  82. actual1, loaded1, k1, v1)
  83. cMap.Range(func(key, value interface{}) bool {
  84. fmt.Printf("The result of an iteration in Range: %v, %v/n",
  85. key, value)
  86. return true
  87. })
  88. }
  89. fmt.Println()
  90. // 示例2。
  91. {
  92. var sMap sync.Map
  93. sMap.Store(pairs[0].k, pairs[0].v)
  94. sMap.Store(pairs[1].k, pairs[1].v)
  95. sMap.Store(pairs[2].k, pairs[2].v)
  96. fmt.Println("[Three pairs have been stored in the sync.Map instance]")
  97. sMap.Range(func(key, value interface{}) bool {
  98. fmt.Printf("The result of an iteration in Range: %v, %v/n",
  99. key, value)
  100. return true
  101. })
  102. k0 := pairs[0].k
  103. v0, ok := sMap.Load(k0)
  104. fmt.Printf("The result of Load: %v, %v (key: %v)/n",
  105. v0, ok, k0)
  106. k3 := pairs[3].k
  107. v3, ok := sMap.Load(k3)
  108. fmt.Printf("The result of Load: %v, %v (key: %v)/n",
  109. v3, ok, k3)
  110. k2, v2 := pairs[2].k, pairs[2].v
  111. actual2, loaded2 := sMap.LoadOrStore(k2, v2)
  112. fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",
  113. actual2, loaded2, k2, v2)
  114. v3 = pairs[3].v
  115. actual3, loaded3 := sMap.LoadOrStore(k3, v3)
  116. fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",
  117. actual3, loaded3, k3, v3)
  118. k1 := pairs[1].k
  119. sMap.Delete(k1)
  120. fmt.Printf("[The pair with the key of %v has been removed from the sync.Map instance]/n",
  121. k1)
  122. v1, ok := sMap.Load(k1)
  123. fmt.Printf("The result of Load: %v, %v (key: %v)/n",
  124. v1, ok, k1)
  125. v1 = pairs[1].v
  126. actual1, loaded1 := sMap.LoadOrStore(k1, v1)
  127. fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",
  128. actual1, loaded1, k1, v1)
  129. sMap.Range(func(key, value interface{}) bool {
  130. fmt.Printf("The result of an iteration in Range: %v, %v/n",
  131. key, value)
  132. return true
  133. })
  134. }}

笔记源码

https://github.com/MingsonZheng/go-core-demo

知识共享许可协议

本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。

欢迎转载、使用、重新发布,但务必保留文章署名 郑子铭 (包含链接: http://www.cnblogs.com/MingsonZheng/ ),不得用于商业目的,基于本文修改后的作品务必以相同的许可发布。

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/125100.html

相关文章

  • Go语言核心36Go语言实战应用八)--学习笔记

    摘要:用于展示一种简易的且更加宽松的互斥锁的模拟。由于这里的原子操作函数只支持非常有限的数据类型,所以在很多应用场景下,互斥锁往往是更加适合的。这主要是因为原子操作函数的执行速度要比互斥锁快得多。30 | 原子操作(下) 我们接着上一篇文章的内容继续聊,上一篇我们提到了,sync/atomic包中的函数可以做的原子操作有:加法(add)、比较并交换(compare and swap,简称 C...

    niuxiaowei111 评论0 收藏0
  • Go语言核心36Go语言实战应用十三)--学习笔记

    摘要:在第二种方案中,我们封装的结构体类型的所有方法,都可以与类型的方法完全一致包括方法名称和方法签名。所以在设计这样的结构体类型的时候,只包含类型的字段就不够了。当参数或的实际类型不符合要求时,方法会立即引发。35 | 并发安全字典sync.Map (下)我们在上一篇文章中谈到了,由于并发安全字典提供的方法涉及的键和值的类型都是interface{},所以我们在调用这些方法的时候,往往还需要对键...

    不知名网友 评论0 收藏0
  • PHPer书单

    摘要:想提升自己,还得多看书多看书多看书下面是我收集到的一些程序员应该看得书单及在线教程,自己也没有全部看完。共勉吧当然,如果你有好的书想分享给大家的或者觉得书单不合理,可以去通过进行提交。讲师温铭,软件基金会主席,最佳实践作者。 想提升自己,还得多看书!多看书!多看书!下面是我收集到的一些PHP程序员应该看得书单及在线教程,自己也没有全部看完。共勉吧!当然,如果你有好的书想分享给大家的或者...

    jimhs 评论0 收藏0
  • SegmentFault 技术周刊 Vol.40 - 2018,来学习一门新的编程语言吧!

    摘要:入门,第一个这是一门很新的语言,年前后正式公布,算起来是比较年轻的编程语言了,更重要的是它是面向程序员的函数式编程语言,它的代码运行在之上。它通过编辑类工具,带来了先进的编辑体验,增强了语言服务。 showImg(https://segmentfault.com/img/bV1xdq?w=900&h=385); 新的一年不知不觉已经到来了,总结过去的 2017,相信小伙们一定有很多收获...

    caspar 评论0 收藏0
  • SegmentFault 技术周刊 Vol.40 - 2018,来学习一门新的编程语言吧!

    摘要:入门,第一个这是一门很新的语言,年前后正式公布,算起来是比较年轻的编程语言了,更重要的是它是面向程序员的函数式编程语言,它的代码运行在之上。它通过编辑类工具,带来了先进的编辑体验,增强了语言服务。 showImg(https://segmentfault.com/img/bV1xdq?w=900&h=385); 新的一年不知不觉已经到来了,总结过去的 2017,相信小伙们一定有很多收获...

    nihao 评论0 收藏0

发表评论

0条评论

不知名网友

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<