浅析go中的map数据结构字典

1. map的使用

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

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

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

package main
import (
 "fmt"
)
// bool 的零值是false
var m map[int]bool
a, ok := m[1]
fmt.Println(a, ok) // false false
// int 的零值是0
var m map[int]int
a, ok := m[1]
fmt.Println(a, ok) // 0 false
func main() {
 var agemap[string]int
 if age== nil {
 fmt.Println("map is nil.")
 age= make(map[string]int)
 }
}

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

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

func main() {
 exp := map[string]int{
 "steve": 20,
 "jamie": 80,
 }
 fmt.Println("Ori exp", age)
 newexp:= exp
 newexp["steve"] = 18
 fmt.Println("exp changed", exp)
}
//Ori age map[steve:20 jamie:80]
//age changed map[steve:18 jamie:80]

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

//正常遍历:
for k, v := range exp {
 fmt.Println(k, v)
}
//有序遍历
import "sort"
var keys []string
// 把key单独抽取出来,放在数组中
for k, _ := range exp {
 keys = append(keys, k)
}
// 进行数组的排序
sort.Strings(keys)
// 遍历数组就是有序的了
for _, k := range keys {
 fmt.Println(k, m[k])
}

2.map的结构

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

type hmap struct {
 count int //元素个数
 flags uint8
 B  uint8 //扩容常量
 noverflow uint16 //溢出 bucket 个数
 hash0 uint32 //hash 种子
 buckets unsafe.Pointer //bucket 数组指针
 oldbuckets unsafe.Pointer //扩容时旧的buckets 数组指针
 nevacuate uintptr //扩容搬迁进度
 extra *mapextra //记录溢出相关
}
type bmap struct {
 tophash [bucketCnt]uint8
 // Followed by bucketCnt keys
 //and then bucketan Cnt values
 // Followed by overflow pointer.
}

  说明:每个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的底层主要是由三个结构构成:

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

  mapextra的结构如下

 // mapextra holds fields that are not present on all maps.
type mapextra struct {
 // If both key and value do not contain pointers and are inline, then we mark bucket
 // type as containing no pointers. This avoids scanning such maps.
 // However, bmap.overflow is a pointer. In order to keep overflow buckets
 // alive, we store pointers to all overflow buckets in hmap.extra.overflow and hmap.extra.oldoverflow.
 // overflow and oldoverflow are only used if key and value do not contain pointers.
 // overflow contains overflow buckets for hmap.buckets.
 // oldoverflow contains overflow buckets for hmap.oldbuckets.
 // The indirection allows to store a pointer to the slice in hiter.
 overflow *[]*bmap
 oldoverflow *[]*bmap

 // nextOverflow holds a pointer to a free overflow bucket.
 nextOverflow *bmap
}

  其中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值是否相同。

 type typeAlg struct {
 // function for hashing objects of this type
 // (ptr to object, seed) -> hash
 hash func(unsafe.Pointer, uintptr) uintptr
 // function for comparing objects of this type
 // (ptr to object A, ptr to object B) -> ==?
 equal func(unsafe.Pointer, unsafe.Pointer) bool

// tophash calculates the tophash value for hash.
func tophash(hash uintptr) uint8 {
 top := uint8(hash >> (sys.PtrSize*8 - 8))
 if top < minTopHash {
 top += minTopHash
 }
 return top
}

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

3.map的基本操作

3.1map的创建

//makemap为make(map [k] v,hint)实现Go map创建。
//如果编译器已确定映射或第一个存储桶,可以在堆栈上创建,hmap或bucket可以为非nil。
//如果h!= nil,则可以直接在h中创建map。
//如果h.buckets!= nil,则指向的存储桶可以用作第一个存储桶。
func makemap(t *maptype, hint int, h *hmap) *hmap {
 if hint < 0 || hint > int(maxSliceCap(t.bucket.size)) {
 hint = 0
 }
 // 初始化Hmap
 if h == nil {
 h = new(hmap)
 }
 h.hash0 = fastrand()
 // 查找将保存请求的元素数的size参数
 B := uint8(0)
 for overLoadFactor(hint, B) {
 B++
 }
 h.B = B
 // 分配初始哈希表
 // if B == 0, 稍后会延迟分配buckets字段(在mapassign中)
 //如果提示很大,则将内存清零可能需要一段时间。
 if h.B != 0 {
 var nextOverflow *bmap
 h.buckets, nextOverflow = makeBucketArray(t, h.B, nil)
 if nextOverflow != nil {
  h.extra = new(mapextra)
  h.extra.nextOverflow = nextOverflow
 }
 }
 return h
}

  hint是一个启发值,启发初建map时创建多少个bucket,如果hint是0那么就先不分配bucket,lazy分配。大概流程就是初始化hmap结构体、设置一下hash seed、bucket数量、实际申请bucket、申请mapextra结构体之类的。  申请buckets的过程:

// makeBucketArray初始化地图存储区的后备数组。
// 1 << b是要分配的最小存储桶数。
// dirtyalloc之前应该为nil或bucket数组
//由makeBucketArray使用相同的t和b参数分配。
//如果dirtyalloc为零,则将分配一个新的支持数组,dirtyalloc将被清除并作为后备数组重用。
func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
 base := bucketShift(b)
 nbuckets := base
 // 对于小b,溢出桶不太可能出现。
 // 避免计算的开销。
 if b >= 4 {
 //加上估计的溢出桶数
 //插入元素的中位数
 //与此值b一起使用。
 nbuckets += bucketShift(b - 4)
 sz := t.bucket.size * nbuckets
 up := roundupsize(sz)
 if up != sz {
  nbuckets = up / t.bucket.size
 }
 }
 if dirtyalloc == nil {
 buckets = newarray(t.bucket, int(nbuckets))
 } else {
 // dirtyalloc先前是由上面的newarray(t.bucket,int(nbuckets)),但不能为空。
 buckets = dirtyalloc
 size := t.bucket.size * nbuckets
 if t.bucket.kind&kindNoPointers == 0 {
  memclrHasPointers(buckets, size)
 } else {
  memclrNoHeapPointers(buckets, size)
 }
 }

 if base != nbuckets {
 //我们预先分配了一些溢出桶。
 //为了将跟踪这些溢出桶的开销降至最低,我们使用的约定是,如果预分配的溢出存储桶发生了溢出指针为零,则通过碰撞指针还有更多可用空间。
 //对于最后一个溢出存储区,我们需要一个安全的非nil指针;只是用bucket。
 nextOverflow = (*bmap)(add(buckets, base*uintptr(t.bucketsize)))
 last := (*bmap)(add(buckets, (nbuckets-1)*uintptr(t.bucketsize)))
 last.setoverflow(t, (*bmap)(buckets))
 }
 return buckets, nextOverflow
}

  默认创建2b个bucket,如果b大于等于4,那么就预先额外创建一些overflow bucket。除了最后一个overflow bucket,其余overflow bucket的overflow指针都是nil,最后一个overflow bucket的overflow指针指向bucket数组第一个元素,作为哨兵,说明到了到结尾了。

3.2 查询操作

// mapaccess1返回指向h [key]的指针。从不返回nil,而是 如果值类型为零,它将返回对零对象的引用,该键不在map中。
 //注意:返回的指针可能会使整个map保持活动状态,因此请不要坚持很长时间。
 func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 if raceenabled && h != nil { //raceenabled是否启用数据竞争检测。
 callerpc := getcallerpc()
 pc := funcPC(mapaccess1)
 racereadpc(unsafe.Pointer(h), callerpc, pc)
 raceReadObjectPC(t.key, key, callerpc, pc)
 }
 if msanenabled && h != nil {
 msanread(key, t.key.size)
 }
 if h == nil || h.count == 0 {
 return unsafe.Pointer(&zeroVal[0])
 }
 // 并发访问检查
 if h.flags&hashWriting != 0 {
 throw("concurrent map read and map write")
 }
 // 计算key的hash值
 alg := t.key.alg
 hash := alg.hash(key, uintptr(h.hash0)) // alg.hash
 // hash值对m取余数得到对应的bucket
 m := uintptr(1)<<h.B - 1
 b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
 // 如果老的bucket还没有迁移,则在老的bucket里面找
 if c := h.oldbuckets; c != nil {
 if !h.sameSizeGrow() {
  m >>= 1
 }
 oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
 if !evacuated(oldb) {
  b = oldb
 }
 }
 // 计算tophash,取高8位
 top := uint8(hash >> (sys.PtrSize*8 - 8))
 for {
 for i := uintptr(0); i < bucketCnt; i++ {
  // 检查top值,如高8位不一样就找下一个
  if b.tophash[i] != top {
  continue
  }
  // 取key的地址
  k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
  if alg.equal(key, k) { // alg.equal
  // 取value得地址
  v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  }
 }
 // 如果当前bucket没有找到,则找bucket链的下一个bucket
 b = b.overflow(t)
 if b == nil {
  // 返回零值
  return unsafe.Pointer(&zeroVal[0])
 }
 }
}

先定位出bucket,如果正在扩容,并且这个bucket还没搬到新的hash表中,那么就从老的hash表中查找。

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

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

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

3.3 更新/插入过程

// 与mapaccess类似,但是如果map中不存在密钥,则为该密钥分配一个插槽
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 ...
 //设置hashWriting调用alg.hash,因为alg.hash可能出现紧急情况后,在这种情况下,我们实际上并没有进行写操作.
 h.flags |= hashWriting
 if h.buckets == nil {
 h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
 }
again:
 bucket := hash & bucketMask(h.B)
 if h.growing() {
 growWork(t, h, bucket)
 }
 b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + bucket*uintptr(t.bucketsize)))
 top := tophash(hash)
 var inserti *uint8
 var insertk unsafe.Pointer
 var val unsafe.Pointer
 for {
 for i := uintptr(0); i < bucketCnt; i++ {
  if b.tophash[i] != top {
  if b.tophash[i] == empty && inserti == nil {
   inserti = &b.tophash[i]
   insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
   val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  }
  continue
  }
  k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
  if t.indirectkey {
  k = *((*unsafe.Pointer)(k))
  }
  if !alg.equal(key, k) {
  continue
  }
  // 已经有一个 mapping for key. 更新它.
  if t.needkeyupdate {
  typedmemmove(t.key, k, key)
  }
  val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  goto done
 }
 ovf := b.overflow(t)
 if ovf == nil {
  break
 }
 b = ovf
 }
 //// 如果已经达到了load factor的最大值,就继续扩容。
 //找不到键的映射。分配新单元格并添加条目。
 //如果达到最大负载系数或溢出桶过多,并且我们还没有处于成长的中间,就开始扩容。
 if !h.growing() && (overLoadFactor(h.count+1, h.B) ||
 tooManyOverflowBuckets(h.noverflow, h.B)) {
 hashGrow(t, h)
 goto again // //扩大表格会使所有内容无效, so try again
 }
 if inserti == nil {
 // 当前所有存储桶已满,请分配一个新的存储桶
 newb := h.newoverflow(t, b)
 inserti = &newb.tophash[0]
 insertk = add(unsafe.Pointer(newb), dataOffset)
 val = add(insertk, bucketCnt*uintptr(t.keysize))
 }
 // 在插入的位置,存储键值
 if t.indirectkey {
 kmem := newobject(t.key)
 *(*unsafe.Pointer)(insertk) = kmem
 insertk = kmem
 }
 if t.indirectvalue {
 vmem := newobject(t.elem)
 *(*unsafe.Pointer)(val) = vmem
 }
 typedmemmove(t.key, insertk, key)
 *inserti = top
 h.count++
done:
 if h.flags&hashWriting == 0 {
 throw("concurrent map writes")
 }
 h.flags &^= hashWriting
 if t.indirectvalue {
 val = *((*unsafe.Pointer)(val))
 }
 return val
} 

hash表如果正在扩容,并且这次要操作的bucket还没搬到新hash表中,那么先进行搬迁(扩容细节下面细说)。

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

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

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

3.5 删除的过程

func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 ...
 // Set hashWriting after calling alg.hash, since alg.hash may panic,
 // in which case we have not actually done a write (delete).
 h.flags |= hashWriting
 bucket := hash & bucketMask(h.B)
 if h.growing() {
 growWork(t, h, bucket)
 }
 b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
 top := tophash(hash)
search:
 for ; b != nil; b = b.overflow(t) {
 for i := uintptr(0); i < bucketCnt; i++ {
  if b.tophash[i] != top {
  continue
  }
  k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
  k2 := k
  if t.indirectkey {
  k2 = *((*unsafe.Pointer)(k2))
  }
  if !alg.equal(key, k2) {
  continue
  }
  // 如果其中有指针,则仅清除键。
  if t.indirectkey {
  *(*unsafe.Pointer)(k) = nil
  } else if t.key.kind&kindNoPointers == 0 {
  memclrHasPointers(k, t.key.size)
  }
  v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  if t.indirectvalue {
  *(*unsafe.Pointer)(v) = nil
  } else if t.elem.kind&kindNoPointers == 0 {
  memclrHasPointers(v, t.elem.size)
  } else {
  memclrNoHeapPointers(v, t.elem.size)
  }
 // 若找到把对应的tophash里面的打上空的标记
  b.tophash[i] = empty
  h.count--
  break search
 }
 }
 if h.flags&hashWriting == 0 {
 throw("concurrent map writes")
 }
 h.flags &^= hashWriting
} 

如果正在扩容,并且操作的bucket还没搬迁完,那么搬迁bucket。

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

3.6 map的扩容

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

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

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

//仅对hash表进行扩容,这里不进行搬迁
func hashGrow(t *maptype, h *hmap) {
 // 如果达到负载系数,则增大尺寸。否则,溢出bucket过多,因此,保持相同数量的存储桶并横向“增长”。
 bigger := uint8(1)
 if !overLoadFactor(h.count+1, h.B) {
 bigger = 0
 h.flags |= sameSizeGrow
 }
 oldbuckets := h.buckets
 newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger, nil)
 flags := h.flags &^ (iterator | oldIterator)
 if h.flags&iterator != 0 {
 flags |= oldIterator
 }
 // 提交增长(atomic wrt gc)
 h.B += bigger
 h.flags = flags
 h.oldbuckets = oldbuckets
 h.buckets = newbuckets
 h.nevacuate = 0
 h.noverflow = 0
 if h.extra != nil && h.extra.overflow != nil {
 // 将当前的溢出bucket提升到老一代。
 if h.extra.oldoverflow != nil {
  throw("oldoverflow is not nil")
 }
 h.extra.oldoverflow = h.extra.overflow
 h.extra.overflow = nil
 }
 if nextOverflow != nil {
 if h.extra == nil {
  h.extra = new(mapextra)
 }
 h.extra.nextOverflow = nextOverflow
 }
 //哈希表数据的实际复制是增量完成的,通过growWork()和evacuate()。
}

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

func growWork(t *maptype, h *hmap, bucket uintptr) {
 //确保我们迁移了了对应的oldbucket,到我们将要使用的存储桶。
 evacuate(t, h, bucket&h.oldbucketmask())
 // 疏散一个旧桶以在生长上取得进展
 if h.growing() {
 evacuate(t, h, h.nevacuate)
 }
}

  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进行数据的增加:

func main() {
 test := map[int]int {1:1}
 go func() {
 i := 0
 for i < 10000 {
  test[1]=1
  i++
 }
 }()
 go func() {
 i := 0
 for i < 10000 {
  test[1]=1
  i++
 }
 }()
 time.Sleep(2*time.Second)
 fmt.Println(test)
}
//fatal error: concurrent map read and map write

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

  解决方案1:加锁

func main() {
 test := map[int]int {1:1}
 var s sync.RWMutex
 go func() {
 i := 0
 for i < 10000 {
  s.Lock()
  test[1]=1
  s.Unlock()
  i++
 }
 }()
 go func() {
 i := 0
 for i < 10000 {
  s.Lock()
  test[1]=1
  s.Unlock()
  i++
 }
 }()
 time.Sleep(2*time.Second)
 fmt.Println(test)
}

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

  解决方案2:sync.Map

func main() {
 test := sync.Map{}
 test.Store(1, 1)
 go func() {
 i := 0
 for i < 10000 {
  test.Store(1, 1)
  i++
 }
 }()

 go func() {
 i := 0
 for i < 10000 {
  test.Store(1, 1)
  i++
 }
 }()

 time.Sleep(time.Second)
 fmt.Println(test.Load(1))
}

  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了,不会回收。

var intMap map[int]int
 func main() {
 printMemStats("初始化")
 // 添加1w个map值
 intMap = make(map[int]int, 10000)
 for i := 0; i < 10000; i++ {
  intMap[i] = i
 }
 // 手动进行gc操作
 runtime.GC()
 // 再次查看数据
 printMemStats("增加map数据后")
 log.Println("删除前数组长度:", len(intMap))
 for i := 0; i < 10000; i++ {
  delete(intMap, i)
 }
 log.Println("删除后数组长度:", len(intMap))
 // 再次进行手动GC回收
 runtime.GC()
 printMemStats("删除map数据后")
 // 设置为nil进行回收
 intMap = nil
 runtime.GC()
 printMemStats("设置为nil后")
 }
 func printMemStats(mag string) {
 var m runtime.MemStats
 runtime.ReadMemStats(&m)
 log.Printf("%v:分配的内存 = %vKB, GC的次数 = %v\n", mag, m.Alloc/1024, m.NumGC)
 }
 //初始化:分配的内存 = 65KB, GC的次数 = 0
 //增加map数据后:分配的内存 = 381KB, GC的次数 = 1
 //删除前数组长度: 10000
 //删除后数组长度: 0
 //删除map数据后:分配的内存 = 381KB, GC的次数 = 2
 //设置为nil后:分配的内存 = 68KB, GC的次数 = 3

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

总结

以上所述是小编给大家介绍的go中的map数据结构字典,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!如果你觉得本文对你有帮助,欢迎转载,烦请注明出处,谢谢!

(0)

相关推荐

  • Go语言中的Array、Slice、Map和Set使用详解

    Array(数组) 内部机制 在 Go 语言中数组是固定长度的数据类型,它包含相同类型的连续的元素,这些元素可以是内建类型,像数字和字符串,也可以是结构类型,元素可以通过唯一的索引值访问,从 0 开始. 数组是很有价值的数据结构,因为它的内存分配是连续的,内存连续意味着可是让它在 CPU 缓存中待更久,所以迭代数组和移动元素都会非常迅速. 数组声明和初始化 通过指定数据类型和元素个数(数组长度)来声明数组. 复制代码 代码如下: // 声明一个长度为5的整数数组 var array [5]int

  • 理解Golang中的数组(array)、切片(slice)和map

    我比较喜欢先给出代码,然后得出结论 数组 复制代码 代码如下: package main import (     "fmt" ) func main() {     arr := [...]int{1, 2, 3}     //打印初始的指针     fmt.Printf("the pointer is : %p \n", &arr)     printPointer(arr) } func printPointer(any interface{}) {

  • golang针对map的判断,删除操作示例

    本文实例讲述了golang针对map的判断,删除操作.分享给大家供大家参考,具体如下: map是一种key-value的关系,一般都会使用make来初始化内存,有助于减少后续新增操作的内存分配次数.假如一开始定义了话,但没有用make来初始化,会报错的. 复制代码 代码如下: package main import ( "fmt" ) func main(){ var test =  map[string]string{"姓名":"李四",&qu

  • Go中map数据类型3点小知识

    1.map数据类型初始化 两种方式:map[string]string{}或make(map[string]string) 2.未初始化的map是nil,它与一个空map基本等价,只是nil的map不允许往里面添加值.(A nil map is equivalent to an empty map except that no elements may be added) 因此,map是nil时,取值是不会报错的(取不到而已),但增加值会报错. 其实,还有一个区别,delete一个nil map

  • MongoDB系列教程(七):MongoDb数据结构详解

    首先,向数据库插入一条bjson数据 首先是定义文档,然后使用admin用户名密码登录,进入test数据库,向test数据库中插入此文档("表名称和表中的记录") 插入结果,查看mongoVUE如下图所示 从上图可以看出系统自带的三个数据库,local,admin,test,在加入一条记录的时候,会自动生成_id的自动标识. 我们再添加图片,可以使用mongoVUE添加,如下图所示. Collections:在mongodb中叫做集合,是文档的集合.无模式,可以存储各种各样的文档.类似

  • go语言map字典删除操作的方法

    本文实例讲述了go语言map字典删除操作的方法.分享给大家供大家参考.具体分析如下: 这里先构造了一点map,添加了青岛.济南.烟台三地的拼音和汉字字典,然后删除青岛,最后查看青岛是否还存在 复制代码 代码如下: package main import "fmt" func main(){     var pc map[string] string     pc = make(map[string] string)     pc["qingdao"] = "

  • Go语言字典(map)用法实例分析【创建,填充,遍历,查找,修改,删除】

    本文实例讲述了Go语言字典(map)用法.分享给大家供大家参考,具体如下: 字典是一种内置的数据结构,用来保存 键值对 的 无序集合. (1)字典的创建 1) make(map[KeyType]ValueType, initialCapacity) 2) make(map[KeyType]ValueType) 3) map[KeyType]ValueType{} 4) map[KeyType]ValueType{key1 : value1, key2 : value2, ... , keyN :

  • 浅析go中的map数据结构字典

    1. map的使用 golang中的map是一种数据类型,将键与值绑定到一起,底层是用哈希表实现的,可以快速的通过键找到对应的值. 类型表示:map[keyType][valueType] key一定要是可比较的类型(可以理解为支持==的操作),value可以是任意类型. 初始化:map只能使用make来初始化,声明的时候默认为一个为nil的map,此时进行取值,返回的是对应类型的零值(不存在也是返回零值).添加元素无任何意义,还会导致运行时错误.向未初始化的map赋值引起 panic: ass

  • 浅析JS中的 map, filter, some, every, forEach, for in, for of 用法总结

    1.map 有返回值,返回一个新的数组,每个元素为调用func的结果. let list = [1, 2, 3, 4, 5]; let other = list.map((d, i) => { return d * 2; }); console.log(other); // print: [2, 4, 6, 8, 10] 2.filter 有返回值,返回一个符合func条件的元素数组 let list = [1, 2, 3, 4, 5]; let other = list.filter((d,

  • JavaScript中的Map数据结构详解

    目录 1. 什么是 Map 2. Map 构造函数 2.1) 数组 2.2) Set 2.3) Map 3. Map 的实例属性和方法 3.1) Map 的属性 size 3.2) Map 的方法 set get has delete clear forEach 4. Map的注意事项 5. Map的使用场景 总结 1. 什么是 Map Map 就是映射的意思,即从键到值的映射. Map 保存键值对,并且能够记住键的原始插入顺序. 那么它和 Object 有什么区别 ? 对象一般用字符串作键 c

  • 浅析java中遍历map的两种方式

    话不多说,直奔主题,跟着小编一起往下看: 1.先将map对象转成set,然后再转为迭代器 Iterator iterator = map.entrySet().iterator(); while(iterator.hasNext()){ Entry entry = iterator.next(); System.out.println(entry.getKey()); // 获取key System.out.println(entry.getValue()); // 获取value } 2.先将

  • ES6中Set和Map数据结构,Map与其它数据结构互相转换操作实例详解

    本文实例讲述了ES6中Set和Map数据结构,Map与其它数据结构互相转换操作.分享给大家供大家参考,具体如下: ES6 的 Set: ES6 提供了新的数据结构──Set.它类似于数组,但是成员的值都是唯一的,没有重复的值. Set 本身是一个构造函数,用来生成 Set 数据结构. Array和Set对比 都是一个存储多值的容器,两者可以互相转换,但是在使用场景上有区别.如下: ①Array的indexOf方法比Set的has方法效率低下 ②Set不含有重复值(可以利用这个特性实现对一个数组的

  • 浅析java中Pair和Map的区别

    在这篇文章中,我们讨论了一个非常有用的编程概念,配对(Pair).配对提供了一种方便方式来处理简单的键值关联,当我们想从方法返回两个值时特别有用. 在核心Java库中可以使用配对(Pair)的实现.除此之外,某些第三方库,比如Apache Commons和Vavr,已经在各自的api中公开了这个功能. 核心java配对实现 Pair类 Pair类在javafx.util 包中,类构造函数有两个参数,键及对应值: Pair<Integer, String> pair = new Pair<

  • ES6中Set和Map数据结构的简单讲解

    目录 Set Map 总结 Set ES6 提供了新的数据结构 Set.它类似于数组,但是成员的值都是唯一的,没有重复的值. Set本身是一个构造函数,用来生成 Set 数据结构. const s = new Set(); [2, 3, 5, 4, 5, 2, 2].forEach(x => s.add(x)); for (let i of s) { console.log(i); } // 2 3 5 4 上面代码通过add()方法向 Set 结构加入成员,结果表明 Set 结构不会添加重复的

  • 详解ES6中的 Set Map 数据结构学习总结

    ES6中的 Set 数据结构 ES6 新增了一种 Set 数据结构.它类似数组. 最重要的一点是 Set中的结构成员没有重复的, 可用这点 一行代码实现数组去重. Set 本身是一个构造函数.通过 new Set() 来创建Set结构. let arr1 = ['Hello', 'World', 'ES6'] let set1 = new Set() arr1.forEach(type => { set1.add(type) }) 通过new Set创建一个Set结构. forEach 遍历ar

  • 深入浅析python中的多进程、多线程、协程

    进程与线程的历史 我们都知道计算机是由硬件和软件组成的.硬件中的CPU是计算机的核心,它承担计算机的所有任务. 操作系统是运行在硬件之上的软件,是计算机的管理者,它负责资源的管理和分配.任务的调度. 程序是运行在系统上的具有某种功能的软件,比如说浏览器,音乐播放器等. 每次执行程序的时候,都会完成一定的功能,比如说浏览器帮我们打开网页,为了保证其独立性,就需要一个专门的管理和控制执行程序的数据结构--进程控制块. 进程就是一个程序在一个数据集上的一次动态执行过程. 进程一般由程序.数据集.进程控

  • 深入浅析React中diff算法

    React中diff算法的理解 diff算法用来计算出Virtual DOM中改变的部分,然后针对该部分进行DOM操作,而不用重新渲染整个页面,渲染整个DOM结构的过程中开销是很大的,需要浏览器对DOM结构进行重绘与回流,而diff算法能够使得操作过程中只更新修改的那部分DOM结构而不更新整个DOM,这样能够最小化操作DOM结构,能够最大程度上减少浏览器重绘与回流的规模. 虚拟DOM diff算法的基础是Virtual DOM,Virtual DOM是一棵以JavaScript对象作为基础的树,

随机推荐