浅析go中的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)
 }
}

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]

//正常遍历：
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])
}

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.
}

 // 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
}

 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
}

//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
}

// 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
}

// 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)<>= 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])
 }
 }
}

// 与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
} 

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
} 

// 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)) {
 进行扩容
 //}
 ....
}

//仅对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（）。
}

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

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

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)
}

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))
}

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