go Map

a := map[string]string{}

type hmap struct {
	count     int // （记录已经存储的键值对的数量） # live cells == size of map.  Must be first (used by len() builtin)
	flags     uint8
	B         uint8  // （桶的数目，是2^B） log_2 of # of buckets (can hold up to loadFactor * 2^B items) 
	noverflow uint16 // （记录使用溢出桶的数量）approximate number of overflow buckets; see incrnoverflow for details
	hash0     uint32 // hash seed

	buckets    unsafe.Pointer // （记录桶的位置。需要扩容时，即分配更多的桶，叫新桶） array of 2^B Buckets. may be nil if count==0.
	oldbuckets unsafe.Pointer // （扩容阶段记录旧桶的位置）previous bucket array of half the size, non-nil only when growing
  nevacuate  uintptr        //（记录旧桶迁移的进度，如下一个将要迁移的桶编号） progress counter for evacuation (buckets less than this have been evacuated)

	extra *mapextra // 指向mapextra结构体，optional fields 
}

type mapextra struct {
	// If both key and elem 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 elem 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 // 下一个空闲溢出桶
}

bucketCntBits = 3	
bucketCnt     = 1 << bucketCntBits

// A bucket for a Go map.
type bmap struct {
	// tophash generally contains the top byte of the hash value
	// for each key in this bucket. If tophash[0] < minTopHash,
	// tophash[0] is a bucket evacuation state instead.
	tophash [bucketCnt]uint8
	// Followed by bucketCnt keys and then bucketCnt elems.
	// NOTE: packing all the keys together and then all the elems together makes the
	// code a bit more complicated than alternating key/elem/key/elem/... but it allows
	// us to eliminate padding which would be needed for, e.g., map[int64]int8.
	// Followed by an overflow pointer.
}

m := make(map[string]int)
//增加元素
m["hello"] = 123
fmt.Println(m["hello"]) //123

//删除
delete(m, "hello")
fmt.Println(m["hello"]) // 0

package main
import (
   "fmt"
   "sync"
   "time"
)
func main() {
   var lock sync.RWMutex
   mymap := make(map[int]string)
   mymap[1] = "3"
   mymap[2] = "2"
   mymap[3] = "1"
   for i := 0; i < 100; i++ {
      go func(i int) {
         lock.Lock()
         mymap[i+1] = "3"
         lock.Unlock()
      }(i)
   }
   for i := 0; i < 100; i++ {
      go func(i int) {
         lock.Lock()
         fmt.Println(mymap[i+1])
         lock.Unlock()
      }(i)
   }
   time.Sleep(time.Second)
}

if _, ok := mymap[pre]; ok {
  // do something
}

func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
	// If the threshold is too low, we do extraneous work.
	// If the threshold is too high, maps that grow and shrink can hold on to lots of unused memory.
	// "too many" means (approximately) as many overflow buckets as regular buckets.
	// See incrnoverflow for more details.
	if B > 15 {
		B = 15
	}
	// The compiler doesn't see here that B < 16; mask B to generate shorter shift code.
	return noverflow >= uint16(1)<<(B&15)
}