go语言map的内部实现及传参

我们知道go的内置函数make返回一个Type类型的对象

func make(Type, size IntegerType) Type 

然后直接上源码：

// Builds a type representing a Hmap structure for the given map type.
// Make sure this stays in sync with ../../../../runtime/hashmap.go!
func hmap(t *Type) *Type {
   if t.MapType().Hmap != nil {
      return t.MapType().Hmap
   }

   bucket := mapbucket(t)
   var field [8]*Field
   field[0] = makefield("count", Types[TINT])
   field[1] = makefield("flags", Types[TUINT8])
   field[2] = makefield("B", Types[TUINT8])
   field[3] = makefield("hash0", Types[TUINT32])
   field[4] = makefield("buckets", Ptrto(bucket))
   field[5] = makefield("oldbuckets", Ptrto(bucket))
   field[6] = makefield("nevacuate", Types[TUINTPTR])
   field[7] = makefield("overflow", Types[TUNSAFEPTR])

   h := typ(TSTRUCT)
   h.Noalg = true
   h.Local = t.Local
   h.SetFields(field[:])
   dowidth(h)
   t.MapType().Hmap = h
   h.StructType().Map = t
   return h
}

// MapType contains Type fields specific to maps.
type MapType struct {
   Key *Type // Key type
   Val *Type // Val (elem) type

   Bucket *Type // internal struct type representing a hash bucket
   Hmap   *Type // internal struct type representing the Hmap (map header object)
   Hiter  *Type // internal struct type representing hash iterator state
}

// MapType returns t's extra map-specific fields.
func (t *Type) MapType() *MapType {
   t.wantEtype(TMAP)
   return t.Extra.(*MapType)
}
// A header for a Go map.
type hmap struct {
   // Note: the format of the Hmap is encoded in ../../cmd/internal/gc/reflect.go and
   // ../reflect/type.go. Don't change this structure without also changing that code!
   count int // # live cells == size of map.  Must be first (used by len() builtin)
   flags uint8
   B     uint8  // log_2 of # of buckets (can hold up to loadFactor * 2^B items)
   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)

   // 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.overflow.
   // Overflow is used only if key and value do not contain pointers.
   // overflow[0] contains overflow buckets for hmap.buckets.
   // overflow[1] contains overflow buckets for hmap.oldbuckets.
   // The first indirection allows us to reduce static size of hmap.
   // The second indirection allows to store a pointer to the slice in hiter.
   overflow *[2]*[]*bmap
}
func hashGrow(t *maptype, h *hmap) {
   if h.oldbuckets != nil {
      throw("evacuation not done in time")
   }
   oldbuckets := h.buckets
   newbuckets := newarray(t.bucket, 1<<(h.B+1))
   flags := h.flags &^ (iterator | oldIterator)
   if h.flags&iterator != 0 {
      flags |= oldIterator
   }
   // commit the grow (atomic wrt gc)
   h.B++
   h.flags = flags
   h.oldbuckets = oldbuckets
   h.buckets = newbuckets
   h.nevacuate = 0

   if h.overflow != nil {
      // Promote current overflow buckets to the old generation.
      if h.overflow[1] != nil {
         throw("overflow is not nil")
      }
      h.overflow[1] = h.overflow[0]
      h.overflow[0] = nil
   }

   // the actual copying of the hash table data is done incrementally
   // by growWork() and evacuate().
}
源码解析：
对于map类型Type实例中，包含一个MapType结构指针，而MapType中包含了Hmap结构指针，
Hmap指向一个hmap结构体，该结构体中的buckets和oldbuckets对应着真实的key/value数据，map重新分桶时，
buckets改变，但hmap的地址不会改变
图示：
Type{  //A实例             
Hmap *Type //指向hmap
}
                                     //hmap在make时才会生成
                                   type hmap struct {
map实例A传参后，                       buckets    unsafe.Pointer ----------->  类型数(实际数据key/value)
在函数内得到A的拷贝实例B               oldbuckets unsafe.Pointer                              
                                   }
Type{ //B实例
Hmap *Type  //指向A指向的hmap
}