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

2021年11月25日 阅读数:3
这篇文章主要向大家介绍Go语言核心36讲(Go语言实战与应用十二)--学习笔记,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

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

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

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

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

在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 语言编译器帮助你作类型检查。请看下面的代码:

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 语言的编译器帮咱们作检查。

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

package main

import (
	"fmt"
	"sync"
)

// ConcurrentMap 表明自制的简易并发安全字典。
type ConcurrentMap struct {
	m  map[interface{}]interface{}
	mu sync.RWMutex
}

func NewConcurrentMap() *ConcurrentMap {
	return &ConcurrentMap{
		m: make(map[interface{}]interface{}),
	}
}

func (cMap *ConcurrentMap) Delete(key interface{}) {
	cMap.mu.Lock()
	defer cMap.mu.Unlock()
	delete(cMap.m, key)
}

func (cMap *ConcurrentMap) Load(key interface{}) (value interface{}, ok bool) {
	cMap.mu.RLock()
	defer cMap.mu.RUnlock()
	value, ok = cMap.m[key]
	return
}

func (cMap *ConcurrentMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
	cMap.mu.Lock()
	defer cMap.mu.Unlock()
	actual, loaded = cMap.m[key]
	if loaded {
		return
	}
	cMap.m[key] = value
	actual = value
	return
}

func (cMap *ConcurrentMap) Range(f func(key, value interface{}) bool) {
	cMap.mu.RLock()
	defer cMap.mu.RUnlock()
	for k, v := range cMap.m {
		if !f(k, v) {
			break
		}
	}
}

func (cMap *ConcurrentMap) Store(key, value interface{}) {
	cMap.mu.Lock()
	defer cMap.mu.Unlock()
	cMap.m[key] = value
}

func main() {
	pairs := []struct {
		k int
		v string
	}{
		{k: 1, v: "a"},
		{k: 2, v: "b"},
		{k: 3, v: "c"},
		{k: 4, v: "d"},
	}

	// 示例1。
	{
		cMap := NewConcurrentMap()
		cMap.Store(pairs[0].k, pairs[0].v)
		cMap.Store(pairs[1].k, pairs[1].v)
		cMap.Store(pairs[2].k, pairs[2].v)
		fmt.Println("[Three pairs have been stored in the ConcurrentMap instance]")

		cMap.Range(func(key, value interface{}) bool {
			fmt.Printf("The result of an iteration in Range: %v, %v\n",
				key, value)
			return true
		})

		k0 := pairs[0].k
		v0, ok := cMap.Load(k0)
		fmt.Printf("The result of Load: %v, %v (key: %v)\n",
			v0, ok, k0)

		k3 := pairs[3].k
		v3, ok := cMap.Load(k3)
		fmt.Printf("The result of Load: %v, %v (key: %v)\n",
			v3, ok, k3)

		k2, v2 := pairs[2].k, pairs[2].v
		actual2, loaded2 := cMap.LoadOrStore(k2, v2)
		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
			actual2, loaded2, k2, v2)
		v3 = pairs[3].v
		actual3, loaded3 := cMap.LoadOrStore(k3, v3)
		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
			actual3, loaded3, k3, v3)

		k1 := pairs[1].k
		cMap.Delete(k1)
		fmt.Printf("[The pair with the key of %v has been removed from the ConcurrentMap instance]\n",
			k1)
		v1, ok := cMap.Load(k1)
		fmt.Printf("The result of Load: %v, %v (key: %v)\n",
			v1, ok, k1)
		v1 = pairs[1].v
		actual1, loaded1 := cMap.LoadOrStore(k1, v1)
		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
			actual1, loaded1, k1, v1)

		cMap.Range(func(key, value interface{}) bool {
			fmt.Printf("The result of an iteration in Range: %v, %v\n",
				key, value)
			return true
		})
	}
	fmt.Println()

	// 示例2。
	{
		var sMap sync.Map
		sMap.Store(pairs[0].k, pairs[0].v)
		sMap.Store(pairs[1].k, pairs[1].v)
		sMap.Store(pairs[2].k, pairs[2].v)
		fmt.Println("[Three pairs have been stored in the sync.Map instance]")

		sMap.Range(func(key, value interface{}) bool {
			fmt.Printf("The result of an iteration in Range: %v, %v\n",
				key, value)
			return true
		})

		k0 := pairs[0].k
		v0, ok := sMap.Load(k0)
		fmt.Printf("The result of Load: %v, %v (key: %v)\n",
			v0, ok, k0)

		k3 := pairs[3].k
		v3, ok := sMap.Load(k3)
		fmt.Printf("The result of Load: %v, %v (key: %v)\n",
			v3, ok, k3)

		k2, v2 := pairs[2].k, pairs[2].v
		actual2, loaded2 := sMap.LoadOrStore(k2, v2)
		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
			actual2, loaded2, k2, v2)
		v3 = pairs[3].v
		actual3, loaded3 := sMap.LoadOrStore(k3, v3)
		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
			actual3, loaded3, k3, v3)

		k1 := pairs[1].k
		sMap.Delete(k1)
		fmt.Printf("[The pair with the key of %v has been removed from the sync.Map instance]\n",
			k1)
		v1, ok := sMap.Load(k1)
		fmt.Printf("The result of Load: %v, %v (key: %v)\n",
			v1, ok, k1)
		v1 = pairs[1].v
		actual1, loaded1 := sMap.LoadOrStore(k1, v1)
		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)\n",
			actual1, loaded1, k1, v1)

		sMap.Range(func(key, value interface{}) bool {
			fmt.Printf("The result of an iteration in Range: %v, %v\n",
				key, value)
			return true
		})
	}

}

笔记源码

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

知识共享许可协议

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

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