本文为《Go专家编程》读书笔记~
Go专家编程
常见数据结构实现原理
本章主要介绍常见的数据结构,比如channel、slice、map等,通过对其底层实现原理的分析,来加深认识。
1.1 chan
1.前言
channel是Golang在语言层面提供的goroutine间的通信方式,比Unix管道更易用也更轻便。channel主要用于进 程内各goroutine间通信,如果需要跨进程通信,建议使用分布式系统的方法来解决。
2.chan数据结构
从数据结构可以看出channel由队列、类型信息、goroutine等待队列组成
1. type hchan struct {
2. qcount uint // 当前队列中剩余元素个数
3. dataqsiz uint // 环形队列长度,即可以存放的元素个数
4. buf unsafe.Pointer // 环形队列指针
5. elemsize uint16 // 每个元素的大小
6. closed uint32 // 标识关闭状态
7. elemtype *_type // 元素类型
8. sendx uint // 队列下标,指示元素写入时存放到队列中的位置
9. recvx uint // 队列下标,指示元素从队列的该位置读出
10. recvq waitq // 等待读消息的goroutine队列
11. sendq waitq // 等待写消息的goroutine队列
12. lock mutex // 互斥锁,chan不允许并发读写
13. }
环形队列
chan内部实现了一个环形队列作为其缓冲区,队列的长度是创建chan时指定的。
等待队列
从channel读数据,如果channel缓冲区为空或者没有缓冲区,当前goroutine会被阻塞。
向channel写数据,如 果channel缓冲区已满或者没有缓冲区,当前goroutine会被阻塞。
被阻塞的goroutine将会挂在channel的等待队列中:
- 因读阻塞的goroutine会被向channel写入数据的goroutine唤醒;
- 因写阻塞的goroutine会被从channel读数据的goroutine唤醒;
一般情况下recvq和sendq至少有一个为空。只有一个例外,那就是同一个goroutine使用select语句向 channel一边写数据,一边读数据。
类型信息
一个channel只能传递一种类型的值,类型信息存储在hchan数据结构中。
锁
一个channel同时仅允许被一个goroutine读写。
3.channel读写
向channel写数据
向一个channel中写数据简单过程如下:
- 如果等待接收队列recvq不为空,说明缓冲区中没有数据或者没有缓冲区,此时直接从recvq取出G,并把数据 写入,最后把该G唤醒,结束发送过程;
- 如果缓冲区中有空余位置,将数据写入缓冲区,结束发送过程;
- 如果缓冲区中没有空余位置,将待发送数据写入G,将当前G加入sendq,进入睡眠,等待被读goroutine唤醒;
从channel读数据
关闭channel
关闭channel时会把recvq中的G全部唤醒,本该写入G的数据位置为nil。把sendq中的G全部唤醒,但这些G会 panic。
除此之外,panic出现的常见场景还有:
- 关闭值为nil的channel
- 关闭已经被关闭的channel
- 向已经关闭的channel写数据
1.2 slice
Slice又称动态数组,依托数组实现,可以方便的进行扩容、传递等
从数据结构看Slice很清晰, array指针指向底层数组,len表示切片长度,cap表示底层数组容量。
如果切片的容量小于1024个元素,那么扩容的时候slice的cap就翻番,乘以2;一旦元素个数超过1024个元素,增长因子就变成1.25,即每次增加原来容量的四分之一。
如果扩容之后,还没有触及原数组的容量,那么,切片中的指针指向的位置,就还是原数组,如果扩容之后,超过了原数组的容量,那么,Go就会开辟一块新的内存,把原来的值拷贝过来,这种情况丝毫不会影响到原数组。
//本例中实际执行了两次append操作,第一次空间增长到4,
//所以第二次append不会再扩容,所以新旧两个切片将共用一块存储空间。程序会输出”true”。
func AddElement(slice []int, e int) []int {
return append(slice, e)
}
func main() {
var slice []int
slice = append(slice, 1,2,3)
fmt.Println("容量:", cap(slice)," 长度",len(slice))
newSlice := AddElement(slice, 4)
fmt.Println("容量(没变哦,所以底下相等):", cap(newSlice)," 长度",len(newSlice))
fmt.Println(&slice[0] == &newSlice[0])
}
Slice 扩容
使用append向Slice追加元素时,如果Slice空间不足,将会触发Slice扩容,扩容实际上重新一配一块更大的内 存,将原Slice数据拷贝进新Slice,然后返回新Slice,扩容后再将数据追加进去。
扩容容量的选择遵循以下规则:
- 如果原Slice容量小于1024,则新Slice容量将扩大为原来的2倍;
- 如果原Slice容量大于等于1024,则新Slice容量将扩大为原来的1.25倍;
使用append()向Slice添加一个元素的实现步骤如下:
- 假如Slice容量够用,则将新元素追加进去,Slice.len++,返回原Slice
- 原Slice容量不够,则将Slice先扩容,扩容后得到新Slice
- 将新元素追加进新Slice,Slice.len++,返回新的Slice。
Slice Copy
使用copy()内置函数拷贝两个切片时,会将源切片的数据逐个拷贝到目的切片指向的数组中,拷贝数量取两个切片长度的最小值。
例如长度为10的切片拷贝到长度为5的切片时,将会拷贝5个元素。
也就是说,copy过程中不会发生扩容。
总结
创建切片时可跟据实际需要预分配容量,尽量避免追加过程中扩容操作,有利于提升性能;
切片拷贝时需要判断实际拷贝的元素个数。
谨慎使用多个切片操作同一个数组,以防读写冲突。
每个切片都指向一个底层数组
每个切片都保存了当前切片的长度、底层数组可用容量
使用len()计算切片长度时间复杂度为O(1),不需要遍历切片
使用cap()计算切片容量时间复杂度为O(1),不需要遍历切片
通过函数传递切片时,不会拷贝整个切片,因为切片本身只是个结构体而矣
使用append()向切片追加元素时有可能触发扩容,扩容后将会生成新的切片
map
Golang的map使用哈希表作为底层实现,一个哈希表里可以有多个哈希表节点,也即bucket,而每个bucket就保存 了map中的一个或一组键值对。
hmap.B=2 , 而hmap.buckets长度是2^B为4. 元素经过哈希运算后会落到某个bucket中进行存储。查找过程类似。
bucket数据结构
type bmap struct {
tophash [8]uint8 //存储哈希值的高8位
data byte[1] //key value数据:key/key/key/.../value/value/value...
overflow *bmap //溢出bucket的地址
}
每个bucket可以存储8个键值对。
- tophash是个长度为8的数组,哈希值相同的键(准确的说是哈希值低位相同的键)存入当前bucket时会将哈希值的高位存储在该数组中,以方便后续匹配。
- data区存放的是key-value数据,存放顺序是key/key/key/…value/value/value,如此存放是为了节省字节对齐带来的空间浪费。
- overflow 指针指向的是下一个bucket,据此将所有冲突的键连接起来。
哈希冲突
当有两个或以上数量的键被哈希到了同一个bucket时,我们称这些键发生了冲突。Go使用链地址法来解决键冲突。由 于每个bucket可以存放8个键值对,所以同一个bucket存放超过8个键值对时就会再创建一个键值对,用类似链表的 方式将bucket连接起来。
负载因子
负载因子 = 键数量/bucket数量
例如,对于一个bucket数量为4,包含4个键值对的哈希表来说,这个哈希表的负载因子为1.
哈希表需要将负载因子控制在合适的大小,超过其阀值需要进行rehash,也即键值对重新组织:
- 哈希因子过小,说明空间利用率低
- 哈希因子过大,说明冲突严重,存取效率低
每个哈希表的实现对负载因子容忍程度不同,比如Redis实现中负载因子大于1时就会触发rehash,而Go则在在负载因子达到6.5时才会触发rehash,因为Redis的每个bucket只能存1个键值对,而Go的bucket可能存8个键值对, 所以Go可以容忍更高的负载因子。
渐进式扩容
扩容条件:
- 负载因子 > 6.5时,也即平均每个bucket存储的键值对达到6.5个。
- overflow(溢出bucket的地址)数量 > 2^15时,也即overflow数量超过32768时。
增量扩容
当负载因子过大时,就新建一个bucket,新的bucket长度是原来的2倍,然后旧bucket数据搬迁到新的bucket。 考虑到如果map存储了数以亿计的key-value,一次性搬迁将会造成比较大的延时,Go采用逐步搬迁策略,即每次访 问map时都会触发一次搬迁,每次搬迁2个键值对。
等量扩容
所谓等量扩容,实际上并不是扩大容量,buckets数量不变,重新做一遍类似增量扩容的搬迁动作,把松散的键值对 重新排列一次,以使bucket的使用率更高,进而保证更快的存取。在极端场景下,比如不断的增删,而键值对正好集 中在一小部分的bucket,这样会造成overflow的bucket数量增多,但负载因子又不高,从而无法执行增量搬迁的情况。
查找过程
- 跟据key值算出哈希值
- 取哈希值低位与hmpa.B取模确定bucket位置
- 取哈希值高位在tophash数组中查询
- 如果tophash[i]中存储值也哈希值相等,则去找到该bucket中的key值进行比较
- 当前bucket没有找到,则继续从下个overflow的bucket中查找。
- 如果当前处于搬迁过程,则优先从oldbuckets查找
注:如果查找不到,也不会返回空值,而是返回相应类型的0值。
插入过程
- 跟据key值算出哈希值
- 取哈希值低位与hmap.B取模确定bucket位置
- 查找该key是否已经存在,如果存在则直接更新值
- 如果没找到将key,将key插入
struct
Go的struct声明允许字段附带 Tag 来对字段做一些标记。( Tag 其实是结构体 字段的一个组成部分。)
Tag
Tag 本身是一个字符串,但字符串中却是: 以空格分隔的 key:value 对 。
- key : 必须是非空字符串,字符串不能包含控制字符、空格、引号、冒号。
- value : 以双引号标记的字符串 注意:冒号前后不能有空格
type Server struct {
ServerName string `key1: "value1" key11:"value11"`
ServerIP string `key2: "value2"`
}
本文示例中tag没有任何实际意义,这是为了阐述tag的定义与操作方法,也为了避免与你之前见过的诸 如 json:xxx 混淆。
使用反射可以动态的给结构体成员赋值,正是因为有tag,在赋值前可以使用tag来决定赋值的动作。
比如,官方 的 encoding/json 包,可以将一个JSON数据 Unmarshal 进一个结构体,此过程中就使用了Tag. 该包定义一些规 则,只要参考该规则设置tag就可以将不同的JSON数据转换成结构体。
总之:正是基于struct的tag特性,才有了诸如json、orm等等的应用。
iota
iota常用于const表达式中。
iota代表了const声明块的行索引(下标从0开始)
const声明还有个特点,即第一个常量必须指定一个表达 式,后续的常量如果没有表达式,则继承上面的表达式。
string
- string可以为空(长度为0),但不会是nil;
- string对象不可以修改。
type stringStruct struct {
str unsafe.Pointer // 字符串的首地址
len int // 字符串的长度
}
[]byte转string
需要注意的是这种转换需要一次内存拷贝。
转换过程如下:
- 跟据切片的长度申请内存空间,假设内存地址为p,切片长度为len(b);
- 构建string(string.str = p;string.len = len;)
- 拷贝数据(切片中数据拷贝到新申请的内存空间)
byte切片转换成string的场景很多,为了性能上的考虑,有时候只是临时需要字符串的场景下,byte切片转换成 string时并不会拷贝内存,而是直接返回一个string,这个string的指针(string.str)指向切片的内存。
使用m[string(b)]来查找map(map是string为key,临时把切片b转成string);
字符串拼接,如”<” + “string(b)” + “>”;
字符串比较:string(b) == “foo”
字符串拼接
str := "Str1" + "Str2" + "Str3"
即便有非常多的字符串需要拼接,性能上也有比较好的保证,因为新字符串的内存空间是一次分配完成的,所以性能 消耗主要在拷贝数据上。
一个拼接语句的字符串编译时都会被存放到一个切片中,拼接过程需要遍历两次切片,第一次遍历获取总的字符串长 度,据此申请内存,第二次遍历会把字符串逐个拷贝过去。
Go的实现中,string不包含内存空间,只有一个内存的指针,这样做的好处是string变得非常轻量,可以很方便的进行传递而不用担心内存拷贝。
因为string通常指向字符串字面量,而字符串字面量存储位置是只读段,而不是堆或栈上,所以才有了string不可 修改的约定