zoukankan      html  css  js  c++  java
  • go中的数据结构-字典map

    1. map的使用

      golang中的map是一种数据类型,将键与值绑定到一起,底层是用哈希表实现的,可以快速的通过键找到对应的值。

      类型表示:map[keyType][valueType] key一定要是可比较的类型(可以理解为支持==的操作),value可以是任意类型。

      初始化:map只能使用make来初始化,声明的时候默认为一个为nil的map,此时进行取值,返回的是对应类型的零值(不存在也是返回零值)。添加元素无任何意义,还会导致运行时错误。向未初始化的map赋值引起 panic: assign to entry in nil map。

     1 package main
     2 
     3 import (  
     4     "fmt"
     5 )
     6 
     7 // bool 的零值是false
     8 var m map[int]bool 
     9 a, ok := m[1]
    10 fmt.Println(a, ok) // false  false
    11 
    12 // int 的零值是0
    13 var m map[int]int 
    14 a, ok := m[1]
    15 fmt.Println(a, ok) // 0  false
    16 
    17 
    18 func main() {  
    19     var agemap[string]int
    20     if age== nil {
    21         fmt.Println("map is nil.")
    22         age= make(map[string]int)
    23     }
    24 }

      清空map:对于一个有一定数据的集合 exp,清空的办法就是再次初始化: exp = make(map[string]int),如果后期不再使用该map,则可以直接:exp= nil 即可,但是如果还需要重复使用,则必须进行make初始化,否则无法为nil的map添加任何内容。

      属性:与切片一样,map 是引用类型。当一个 map 赋值给一个新的变量,它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个。作为形参或返回参数的时候,传递的是地址的拷贝,扩容时也不会改变这个地址。

     1 func main() {
     2     exp := map[string]int{
     3         "steve": 20,
     4         "jamie": 80,
     5     }
     6     fmt.Println("Ori exp", age)
     7     newexp:= exp
     8     newexp["steve"] = 18
     9     fmt.Println("exp changed", exp)
    10 }
    11 
    12 //Ori age map[steve:20 jamie:80]
    13 //age changed map[steve:18 jamie:80]

      遍历map:map本身是无序的,在遍历的时候并不会按照你传入的顺序,进行传出。

     1 //正常遍历:
     2 for k, v := range exp { 
     3     fmt.Println(k, v)
     4 }
     5 
     6 //有序遍历
     7 import "sort"
     8 var keys []string
     9 // 把key单独抽取出来,放在数组中
    10 for k, _ := range exp {
    11     keys = append(keys, k)
    12 }
    13 // 进行数组的排序
    14 sort.Strings(keys)
    15 // 遍历数组就是有序的了
    16 for _, k := range keys {
    17     fmt.Println(k, m[k])
    18 }

    2. map的结构

       Go中的map在可以在 $GOROOT/src/runtime/map.go找到它的实现。哈希表的数据结构中一些关键的域如下所示:

     1 type hmap struct {
     2     count        int  //元素个数
     3     flags        uint8   
     4     B            uint8 //扩容常量
     5     noverflow    uint16 //溢出 bucket 个数
     6     hash0        uint32 //hash 种子
     7     buckets      unsafe.Pointer //bucket 数组指针
     8     oldbuckets   unsafe.Pointer //扩容时旧的buckets 数组指针
     9     nevacuate    uintptr  //扩容搬迁进度
    10     extra        *mapextra //记录溢出相关
    11 }
    12 
    13 type bmap struct {
    14     tophash        [bucketCnt]uint8  
    15     // Followed by bucketCnt keys 
    16     //and then bucketan Cnt values  
    17     // Followed by overflow pointer.
    18 } 

      说明:每个map的底层都是hmap结构体,它是由若干个描述hmap结构体的元素、数组指针、extra等组成,buckets数组指针指向由若干个bucket组成的数组,其每个bucket里存放的是key-value数据(通常是8个)和overflow字段(指向下一个bmap),每个key插入时会根据hash算法归到同一个bucket中,当一个bucket中的元素超过8个的时候,hmap会使用extra中的overflow来扩展存储key。

      图中len 就是当前map的元素个数,也就是len()返回的值。也是结构体中hmap.count的值。bucket array是指数组指针,指向bucket数组。hash seed 哈希种子。overflow指向下一个bucket。

    map的底层主要是由三个结构构成:

    1. hmap --- map的最外层的数据结构,包括了map的各种基础信息、如大小、bucket,一个大的结构体。
    2. mapextra --- 记录map的额外信息,hmap结构体里的extra指针指向的结构,例如overflow bucket
    3. bmap --- 代表bucket,每一个bucket最多放8个kv,最后由一个overflow字段指向下一个bmap,注意key、value、overflow字段都不显示定义,而是通过maptype计算偏移获取的。

      mapextra的结构如下

     1 // mapextra holds fields that are not present on all maps.
     2 type mapextra struct {
     3     // If both key and value do not contain pointers and are inline, then we mark bucket
     4     // type as containing no pointers. This avoids scanning such maps.
     5     // However, bmap.overflow is a pointer. In order to keep overflow buckets
     6     // alive, we store pointers to all overflow buckets in hmap.extra.overflow and hmap.extra.oldoverflow.
     7     // overflow and oldoverflow are only used if key and value do not contain pointers.
     8     // overflow contains overflow buckets for hmap.buckets.
     9     // oldoverflow contains overflow buckets for hmap.oldbuckets.
    10     // The indirection allows to store a pointer to the slice in hiter.
    11     overflow    *[]*bmap
    12     oldoverflow *[]*bmap
    13 
    14     // nextOverflow holds a pointer to a free overflow bucket.
    15     nextOverflow *bmap
    16 }

      其中hmap.extra.nextOverflow指向的是预分配的overflow bucket,预分配的用完了那么值就变成nil。

      bmap的详细结构如下

      在map中出现哈希冲突时,首先以bmap为最小粒度挂载,一个bmap累积8个kv之后,就会申请一个新的bmap(overflow bucket)挂在这个bmap的后面形成链表,优先用预分配的overflow bucket,如果预分配的用完了,那么就malloc一个挂上去。这样减少对象数量,减轻管理内存的负担,利于gc。注意golang的map不会shrink,内存只会越用越多,overflow bucket中的key全删了也不会释放。

      bmap中所有key存在一块,所有value存在一块,这样做方便内存对齐。当key大于128字节时,bucket的key字段存储的会是指针,指向key的实际内容;value也是一样。

      hash值的高8位存储在bucket中的tophash字段。每个桶最多放8个kv对,所以tophash类型是数组[8]uint8。把高八位存储起来,这样不用完整比较key就能过滤掉不符合的key,加快查询速度。实际上当hash值的高八位小于常量minTopHash时,会加上minTopHash,区间[0, minTophash)的值用于特殊标记。查找key时,计算hash值,用hash值的高八位在tophash中查找,有tophash相等的,再去比较key值是否相同。

     1 type typeAlg struct {
     2     // function for hashing objects of this type
     3     // (ptr to object, seed) -> hash
     4     hash func(unsafe.Pointer, uintptr) uintptr
     5     // function for comparing objects of this type
     6     // (ptr to object A, ptr to object B) -> ==?
     7     equal func(unsafe.Pointer, unsafe.Pointer) bool
     8 
     9 // tophash calculates the tophash value for hash.
    10 func tophash(hash uintptr) uint8 {
    11     top := uint8(hash >> (sys.PtrSize*8 - 8))
    12     if top < minTopHash {
    13         top += minTopHash
    14     }
    15     return top
    16 }

      golang为每个类型定义了类型描述器_type,并实现了hashable类型的_type.alg.hash和_type.alg.equal,以支持map的范型,定义了这类key用什么hash函数、bucket的大小、怎么比较之类的,通过这个变量来实现范型。

    3. map的基本操作

    3.1 map的创建

     1 //makemap为make(map [k] v,hint)实现Go map创建。
     2 //如果编译器已确定映射或第一个存储桶,可以在堆栈上创建,hmap或bucket可以为非nil。
     3 //如果h!= nil,则可以直接在h中创建map。
     4 //如果h.buckets!= nil,则指向的存储桶可以用作第一个存储桶。
     5 func makemap(t *maptype, hint int, h *hmap) *hmap {
     6     if hint < 0 || hint > int(maxSliceCap(t.bucket.size)) {
     7         hint = 0
     8     }
     9 
    10     // 初始化Hmap
    11     if h == nil {
    12         h = new(hmap)
    13     }
    14     h.hash0 = fastrand()
    15 
    16     // 查找将保存请求的元素数的size参数
    17     B := uint8(0)
    18     for overLoadFactor(hint, B) {
    19         B++
    20     }
    21     h.B = B
    22 
    23     // 分配初始哈希表
    24     // if B == 0, 稍后会延迟分配buckets字段(在mapassign中)
    25     //如果提示很大,则将内存清零可能需要一段时间。
    26     if h.B != 0 {
    27         var nextOverflow *bmap
    28         h.buckets, nextOverflow = makeBucketArray(t, h.B, nil)
    29         if nextOverflow != nil {
    30             h.extra = new(mapextra)
    31             h.extra.nextOverflow = nextOverflow
    32         }
    33     }
    34 
    35     return h
    36 }
      hint是一个启发值,启发初建map时创建多少个bucket,如果hint是0那么就先不分配bucket,lazy分配。大概流程就是初始化hmap结构体、设置一下hash seed、bucket数量、实际申请bucket、申请mapextra结构体之类的。
      申请buckets的过程:
     1 // makeBucketArray初始化地图存储区的后备数组。
     2 // 1 << b是要分配的最小存储桶数。
     3 // dirtyalloc之前应该为nil或bucket数组
     4 //由makeBucketArray使用相同的t和b参数分配。
     5 //如果dirtyalloc为零,则将分配一个新的支持数组,dirtyalloc将被清除并作为后备数组重用。
     6 func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
     7     base := bucketShift(b)
     8     nbuckets := base
     9     // 对于小b,溢出桶不太可能出现。
    10     // 避免计算的开销。
    11     if b >= 4 {
    12         //加上估计的溢出桶数
    13         //插入元素的中位数
    14         //与此值b一起使用。
    15         nbuckets += bucketShift(b - 4)
    16         sz := t.bucket.size * nbuckets
    17         up := roundupsize(sz)
    18         if up != sz {
    19             nbuckets = up / t.bucket.size
    20         }
    21     }
    22     if dirtyalloc == nil {
    23         buckets = newarray(t.bucket, int(nbuckets))
    24     } else {
    25        // dirtyalloc先前是由上面的newarray(t.bucket,int(nbuckets)),但不能为空。
    26         buckets = dirtyalloc
    27         size := t.bucket.size * nbuckets
    28         if t.bucket.kind&kindNoPointers == 0 {
    29             memclrHasPointers(buckets, size)
    30         } else {
    31             memclrNoHeapPointers(buckets, size)
    32         }
    33     }
    34 
    35     if base != nbuckets {
    36         //我们预先分配了一些溢出桶。
    37         //为了将跟踪这些溢出桶的开销降至最低,我们使用的约定是,如果预分配的溢出存储桶发生了溢出指针为零,则通过碰撞指针还有更多可用空间。
    38         //对于最后一个溢出存储区,我们需要一个安全的非nil指针;只是用bucket。
    39         nextOverflow = (*bmap)(add(buckets, base*uintptr(t.bucketsize)))
    40         last := (*bmap)(add(buckets, (nbuckets-1)*uintptr(t.bucketsize)))
    41         last.setoverflow(t, (*bmap)(buckets))
    42     }
    43     return buckets, nextOverflow
    44 }
      默认创建2b个bucket,如果b大于等于4,那么就预先额外创建一些overflow bucket。除了最后一个overflow bucket,其余overflow bucket的overflow指针都是nil,最后一个overflow bucket的overflow指针指向bucket数组第一个元素,作为哨兵,说明到了到结尾了。

    3.2 查询操作

     1 // mapaccess1返回指向h [key]的指针。从不返回nil,而是 如果值类型为零,它将返回对零对象的引用,该键不在map中。
     2   //注意:返回的指针可能会使整个map保持活动状态,因此请不要坚持很长时间。
     3   func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
     4       if raceenabled && h != nil {  //raceenabled是否启用数据竞争检测。
     5         callerpc := getcallerpc()
     6         pc := funcPC(mapaccess1)
     7         racereadpc(unsafe.Pointer(h), callerpc, pc)
     8         raceReadObjectPC(t.key, key, callerpc, pc)
     9     }
    10     if msanenabled && h != nil {
    11         msanread(key, t.key.size)
    12     }
    13     if h == nil || h.count == 0 {
    14         return unsafe.Pointer(&zeroVal[0])
    15     }    
    16     // 并发访问检查
    17     if h.flags&hashWriting != 0 {
    18         throw("concurrent map read and map write")
    19     }
    20     
    21     // 计算key的hash值
    22     alg := t.key.alg
    23     hash := alg.hash(key, uintptr(h.hash0)) // alg.hash
    24 
    25     // hash值对m取余数得到对应的bucket
    26     m := uintptr(1)<<h.B - 1
    27     b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
    28 
    29     // 如果老的bucket还没有迁移,则在老的bucket里面找
    30     if c := h.oldbuckets; c != nil {
    31         if !h.sameSizeGrow() {
    32             m >>= 1
    33         }
    34         oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
    35         if !evacuated(oldb) {
    36             b = oldb
    37         }
    38     }
    39     
    40     // 计算tophash,取高8位
    41     top := uint8(hash >> (sys.PtrSize*8 - 8))
    42     
    43     for {
    44         for i := uintptr(0); i < bucketCnt; i++ {
    45             // 检查top值,如高8位不一样就找下一个
    46             if b.tophash[i] != top {
    47                 continue
    48             }
    49             
    50             // 取key的地址
    51             k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
    52             
    53             if alg.equal(key, k) { // alg.equal
    54                 // 取value得地址
    55                 v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
    56             }
    57         }
    58        
    59         // 如果当前bucket没有找到,则找bucket链的下一个bucket
    60         b = b.overflow(t)
    61         if b == nil {
    62             // 返回零值
    63             return unsafe.Pointer(&zeroVal[0])
    64         }
    65     }
    66 }
    1. 先定位出bucket,如果正在扩容,并且这个bucket还没搬到新的hash表中,那么就从老的hash表中查找。

    2. 在bucket中进行顺序查找,使用高八位进行快速过滤,高八位相等,再比较key是否相等,找到就返回value。如果当前bucket找不到,就往下找overflow bucket,都没有就返回零值。

      访问的时候,并不进行扩容的数据搬迁。并且并发有写操作时抛异常

      注意,t.bucketsize并不是bmap的size,而是bmap加上存储key、value、overflow指针,所以查找bucket的时候时候用的不是bmap的szie。

    3.3 更新/插入过程

     1 // 与mapaccess类似,但是如果map中不存在密钥,则为该密钥分配一个插槽
     2 func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
     3     ...
     4     //设置hashWriting调用alg.hash,因为alg.hash可能出现紧急情况后,在这种情况下,我们实际上并没有进行写操作.
     5     h.flags |= hashWriting
     6 
     7     if h.buckets == nil {
     8         h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
     9     }
    10 
    11 again:
    12     bucket := hash & bucketMask(h.B)
    13     if h.growing() {
    14         growWork(t, h, bucket)
    15     }
    16     b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + bucket*uintptr(t.bucketsize)))
    17     top := tophash(hash)
    18 
    19     var inserti *uint8
    20     var insertk unsafe.Pointer
    21     var val unsafe.Pointer
    22     for {
    23         for i := uintptr(0); i < bucketCnt; i++ {
    24             if b.tophash[i] != top {
    25                 if b.tophash[i] == empty && inserti == nil {
    26                     inserti = &b.tophash[i]
    27                     insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
    28                     val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
    29                 }
    30                 continue
    31             }
    32             k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
    33             if t.indirectkey {
    34                 k = *((*unsafe.Pointer)(k))
    35             }
    36             if !alg.equal(key, k) {
    37                 continue
    38             }
    39             // 已经有一个 mapping for key. 更新它.
    40             if t.needkeyupdate {
    41                 typedmemmove(t.key, k, key)
    42             }
    43             val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
    44             goto done
    45         }
    46         ovf := b.overflow(t)
    47         if ovf == nil {
    48             break
    49         }
    50         b = ovf
    51     }
    52     //// 如果已经达到了load factor的最大值,就继续扩容。
    53     //找不到键的映射。分配新单元格并添加条目。
    54     //如果达到最大负载系数或溢出桶过多,并且我们还没有处于成长的中间,就开始扩容。
    55     if !h.growing() && (overLoadFactor(h.count+1, h.B) ||     
    56         tooManyOverflowBuckets(h.noverflow, h.B)) {
    57         hashGrow(t, h)
    58         goto again // //扩大表格会使所有内容无效, so try again
    59     }
    60     if inserti == nil {
    61         // 当前所有存储桶已满,请分配一个新的存储桶
    62         newb := h.newoverflow(t, b)
    63         inserti = &newb.tophash[0]
    64         insertk = add(unsafe.Pointer(newb), dataOffset)
    65         val = add(insertk, bucketCnt*uintptr(t.keysize))
    66     }
    67 
    68     // 在插入的位置,存储键值
    69     if t.indirectkey {
    70         kmem := newobject(t.key)
    71         *(*unsafe.Pointer)(insertk) = kmem
    72         insertk = kmem
    73     }
    74     if t.indirectvalue {
    75         vmem := newobject(t.elem)
    76         *(*unsafe.Pointer)(val) = vmem
    77     }
    78     typedmemmove(t.key, insertk, key)
    79     *inserti = top
    80     h.count++
    81 
    82 done:
    83     if h.flags&hashWriting == 0 {
    84         throw("concurrent map writes")
    85     }
    86     h.flags &^= hashWriting
    87     if t.indirectvalue {
    88         val = *((*unsafe.Pointer)(val))
    89     }
    90     return val
    91 }    
    • hash表如果正在扩容,并且这次要操作的bucket还没搬到新hash表中,那么先进行搬迁(扩容细节下面细说)。

    • 在buck中寻找key,同时记录下第一个空位置,如果找不到,那么就在空位置中插入数据;如果找到了,那么就更新对应的value;

    • 找不到key就看下需不需要扩容,需要扩容并且没有正在扩容,那么就进行扩容,然后回到第一步。

    • 找不到key,不需要扩容,但是没有空slot,那么就分配一个overflow bucket挂在链表结尾,用新bucket的第一个slot放存放数据。

    3.5 删除的过程

     1 func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
     2     ...
     3     // Set hashWriting after calling alg.hash, since alg.hash may panic,
     4     // in which case we have not actually done a write (delete).
     5     h.flags |= hashWriting
     6 
     7     bucket := hash & bucketMask(h.B)
     8     if h.growing() {
     9         growWork(t, h, bucket)
    10     }
    11     b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
    12     top := tophash(hash)
    13 search:
    14     for ; b != nil; b = b.overflow(t) {
    15         for i := uintptr(0); i < bucketCnt; i++ {
    16             if b.tophash[i] != top {
    17                 continue
    18             }
    19             k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
    20             k2 := k
    21             if t.indirectkey {
    22                 k2 = *((*unsafe.Pointer)(k2))
    23             }
    24             if !alg.equal(key, k2) {
    25                 continue
    26             }
    27             // 如果其中有指针,则仅清除键。
    28             if t.indirectkey {
    29                 *(*unsafe.Pointer)(k) = nil
    30             } else if t.key.kind&kindNoPointers == 0 {
    31                 memclrHasPointers(k, t.key.size)
    32             }
    33             v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
    34             if t.indirectvalue {
    35                 *(*unsafe.Pointer)(v) = nil
    36             } else if t.elem.kind&kindNoPointers == 0 {
    37                 memclrHasPointers(v, t.elem.size)
    38             } else {
    39                 memclrNoHeapPointers(v, t.elem.size)
    40             }
    41         // 若找到把对应的tophash里面的打上空的标记
    42             b.tophash[i] = empty
    43             h.count--
    44             break search
    45         }
    46     }
    47 
    48     if h.flags&hashWriting == 0 {
    49         throw("concurrent map writes")
    50     }
    51     h.flags &^= hashWriting
    52 }    
    1. 如果正在扩容,并且操作的bucket还没搬迁完,那么搬迁bucket。

    2. 找出对应的key,如果key、value是包含指针的那么会清理指针指向的内存,否则不会回收内存。

    3.6 map的扩容

      通过上面的过程我们知道了,插入、删除过程都会触发扩容,判断扩容的函数如下:

     1 // overLoadFactor 判断放置在1 << B个存储桶中的计数项目是否超过loadFactor。
     2 func overLoadFactor(count int, B uint8) bool {
     3     return count > bucketCnt && uintptr(count) > loadFactorNum*(bucketShift(B)/loadFactorDen)  
     4     //return 元素个数>8 && count>bucket数量*6.5,其中loadFactorNum是常量13,loadFactorDen是常量2,所以是6.5,bucket数量不算overflow bucket.
     5 }
     6 
     7 // tooManyOverflowBuckets 判断noverflow存储桶对于1 << B存储桶的map是否过多。
     8 // 请注意,大多数这些溢出桶必须稀疏使用。如果使用密集,则我们已经触发了常规map扩容。
     9 func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
    10     // 如果阈值太低,我们会做多余的工作。如果阈值太高,则增大和缩小的映射可能会保留大量未使用的内存。
    11     //“太多”意味着(大约)溢出桶与常规桶一样多。有关更多详细信息,请参见incrnoverflow。
    12     if B > 15 {
    13         B = 15
    14     }
    15     // 译器在这里看不到B <16;掩码B生成较短的移位码。
    16     return noverflow >= uint16(1)<<(B&15)
    17 }
    18 
    19 {
    20     ....
    21     // 如果我们达到最大负载率或溢流桶过多,并且我们还没有处于成长的中间,就开始成长。
    22     if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
    23         hashGrow(t, h)
    24         goto again // 扩大表格会使所有内容失效,so try again
    25     }
    26     //if (不是正在扩容 && (元素个数/bucket数超过某个值 || 太多overflow bucket)) {
    27     进行扩容
    28     //}
    29     ....
    30 }

      每次map进行更新或者新增的时候,会先通过以上函数判断一下load factor。来决定是否扩容。如果需要扩容,那么第一步需要做的,就是对hash表进行扩容:

     1 //仅对hash表进行扩容,这里不进行搬迁
     2 func hashGrow(t *maptype, h *hmap) {
     3     // 如果达到负载系数,则增大尺寸。否则,溢出bucket过多,因此,保持相同数量的存储桶并横向“增长”。
     4     bigger := uint8(1)
     5     if !overLoadFactor(h.count+1, h.B) {
     6         bigger = 0
     7         h.flags |= sameSizeGrow
     8     }
     9     oldbuckets := h.buckets
    10     newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger, nil)
    11 
    12     flags := h.flags &^ (iterator | oldIterator)
    13     if h.flags&iterator != 0 {
    14         flags |= oldIterator
    15     }
    16     // 提交增长(atomic wrt gc)
    17     h.B += bigger
    18     h.flags = flags
    19     h.oldbuckets = oldbuckets
    20     h.buckets = newbuckets
    21     h.nevacuate = 0
    22     h.noverflow = 0
    23 
    24     if h.extra != nil && h.extra.overflow != nil {
    25         // 将当前的溢出bucket提升到老一代。
    26         if h.extra.oldoverflow != nil {
    27             throw("oldoverflow is not nil")
    28         }
    29         h.extra.oldoverflow = h.extra.overflow
    30         h.extra.overflow = nil
    31     }
    32     if nextOverflow != nil {
    33         if h.extra == nil {
    34             h.extra = new(mapextra)
    35         }
    36         h.extra.nextOverflow = nextOverflow
    37     }
    38 
    39     //哈希表数据的实际复制是增量完成的,通过growWork()和evacuate()。
    40 }

      如果之前为2^n ,那么下一次扩容是2^(n+1),每次扩容都是之前的两倍。扩容后需要重新计算每一项在hash中的位置,新表为老的两倍,此时前文的oldbacket用上了,用来存同时存在的两个新旧map,等数据迁移完毕就可以释放oldbacket了。扩容的函数hashGrow其实仅仅是进行一些空间分配,字段的初始化,实际的搬迁操作是在growWork函数中:

    1 func growWork(t *maptype, h *hmap, bucket uintptr) {
    2     //确保我们迁移了了对应的oldbucket,到我们将要使用的存储桶。
    3     evacuate(t, h, bucket&h.oldbucketmask())
    4 
    5     // 疏散一个旧桶以在生长上取得进展
    6     if h.growing() {
    7         evacuate(t, h, h.nevacuate)
    8     }
    9 }
      evacuate是进行具体搬迁某个bucket的函数,可以看出growWork会搬迁两个bucket,一个是入参bucket;另一个是h.nevacuate。这个nevacuate是一个顺序累加的值。可以想想如果每次仅仅搬迁进行写操作(赋值/删除)的bucket,那么有可能某些bucket就是一直没有机会访问到,那么扩容就一直没法完成,总是在扩容中的状态,因此会额外进行一次顺序迁移,理论上,有N个old bucket,最多N次写操作,那么必定会搬迁完。在advanceEvacuationMark中进行nevacuate的累加,遇到已经迁移的bucket会继续累加,一次最多加1024。

      优点:均摊扩容时间,一定程度上缩短了扩容时间(和gc的引用计数法类似,都是均摊)overLoadFactor函数中有一个常量6.5(loadFactorNum/loadFactorDen)来进行影响扩容时机。这个值的来源是测试取中的结果。

    4. map的并发安全性

      map的并发操作不是安全的。并发起两个goroutine,分别对map进行数据的增加:

     1 func main() {
     2     test := map[int]int {1:1}
     3     go func() {
     4         i := 0
     5         for i < 10000 {
     6             test[1]=1
     7             i++
     8         }
     9     }()
    10 
    11     go func() {
    12         i := 0
    13         for i < 10000 {
    14             test[1]=1
    15             i++
    16         }
    17     }()
    18 
    19     time.Sleep(2*time.Second)
    20     fmt.Println(test)
    21 }
    22 
    23 //fatal error: concurrent map read and map write

      并发读写map结构的数据引起了错误。

      解决方案1:加锁

     1 func main() {
     2     test := map[int]int {1:1}
     3     var s sync.RWMutex
     4     go func() {
     5         i := 0
     6         for i < 10000 {
     7             s.Lock()
     8             test[1]=1
     9             s.Unlock()
    10             i++
    11         }
    12     }()
    13 
    14     go func() {
    15         i := 0
    16         for i < 10000 {
    17             s.Lock()
    18             test[1]=1
    19             s.Unlock()
    20             i++
    21         }
    22     }()
    23 
    24     time.Sleep(2*time.Second)
    25     fmt.Println(test)
    26 }

      特点:实现简单粗暴,好理解。但是锁的粒度为整个map,存在优化空间。适用场景:all。

      解决方案2:sync.Map

     1 func main() {
     2     test := sync.Map{}
     3     test.Store(1, 1)
     4     go func() {
     5         i := 0
     6         for i < 10000 {
     7             test.Store(1, 1)
     8             i++
     9         }
    10     }()
    11 
    12     go func() {
    13         i := 0
    14         for i < 10000 {
    15             test.Store(1, 1)
    16             i++
    17         }
    18     }()
    19 
    20     time.Sleep(time.Second)
    21     fmt.Println(test.Load(1))
    22 }

      sync.Map的原理:sync.Map里头有两个map一个是专门用于读的read map,另一个是才是提供读写的dirty map;优先读read map,若不存在则加锁穿透读dirty map,同时记录一个未从read map读到的计数,当计数到达一定值,就将read map用dirty map进行覆盖。
    特点:官方出品,通过空间换时间的方式,读写分离;不适用于大量写的场景,会导致read map读不到数据而进一步加锁读取,同时dirty map也会一直晋升为read map,整体性能较差。适用场景:大量读,少量写。

      解决方案3:分段锁

      这也是数据库常用的方法,分段锁每一个读写锁保护一段区间。sync.Map其实也是相当于表级锁,只不过多读写分了两个map,本质还是一样的。

      优化方向:将锁的粒度尽可能降低来提高运行速度。思路:对一个大map进行hash,其内部是n个小map,根据key来来hash确定在具体的那个小map中,这样加锁的粒度就变成1/n了。例如

    5. map的GC内存回收

      golang里的map是只增不减的一种数组结构,他只会在删除的时候进行打标记说明该内存空间已经empty了,不会回收。

     1 var intMap map[int]int
     2 
     3 func main() {
     4     printMemStats("初始化")
     5 
     6     // 添加1w个map值
     7     intMap = make(map[int]int, 10000)
     8     for i := 0; i < 10000; i++ {
     9         intMap[i] = i
    10     }
    11 
    12     // 手动进行gc操作
    13     runtime.GC()
    14     // 再次查看数据
    15     printMemStats("增加map数据后")
    16 
    17     log.Println("删除前数组长度:", len(intMap))
    18     for i := 0; i < 10000; i++ {
    19         delete(intMap, i)
    20     }
    21     log.Println("删除后数组长度:", len(intMap))
    22 
    23     // 再次进行手动GC回收
    24     runtime.GC()
    25     printMemStats("删除map数据后")
    26 
    27     // 设置为nil进行回收
    28     intMap = nil
    29     runtime.GC()
    30     printMemStats("设置为nil后")
    31 }
    32 
    33 func printMemStats(mag string) {
    34     var m runtime.MemStats
    35     runtime.ReadMemStats(&m)
    36     log.Printf("%v:分配的内存 = %vKB, GC的次数 = %v
    ", mag, m.Alloc/1024, m.NumGC)
    37 }
    38 
    39 //初始化:分配的内存 = 65KB, GC的次数 = 0
    40 //增加map数据后:分配的内存 = 381KB, GC的次数 = 1
    41 //删除前数组长度: 10000
    42 //删除后数组长度: 0
    43 //删除map数据后:分配的内存 = 381KB, GC的次数 = 2
    44 //设置为nil后:分配的内存 = 68KB, GC的次数 = 3

      可以看到delete是不会真正的把map释放的,所以要回收map还是需要设为nil

    sync.Map的原理详解:https://www.jianshu.com/p/ec51dac3c65b 由浅入深sync.Map

  • 相关阅读:
    JAVA调优总结:JVM垃圾回收面临的问题解决方案
    用什么紧固件来固定一下我的程序人生呢
    Java设计模式动态代理研究分享
    深入理解Asp.net核心对象
    JAVA编程之动态更新JVM中的class文件
    探索J2ME应用:如何用GCF通信
    MySQL数据库备份的命令应用分享
    送给快要放弃的程序员同行们!
    减速机要像人一样智能减速就厉害了
    如何在Linux系统下进行C++程序开发
  • 原文地址:https://www.cnblogs.com/33debug/p/11851585.html
Copyright © 2011-2022 走看看