回顾前景

在上一节中，咱们留了一个代码：

func main() {
    buffer := []byte("test")
    stringData := reflect.StringHeader{
        Data: uintptr(unsafe.Pointer(&buffer[0])),
        Len:  len(buffer),
    }
    str := *(*string)(unsafe.Pointer(&stringData))
    mmp := make(map[string]int, 32)
    mmp[str] = 3
    mmp["abcd"] = 4

    fmt.Println(mmp[str])
    buffer[0] = 'a'
    buffer[1] = 'b'
    buffer[2] = 'c'
    buffer[3] = 'd'
    fmt.Println(mmp[str])
    fmt.Println(mmp["test"])
    fmt.Println(mmp["abcd"])
    for k, v := range mmp {
        fmt.Println(k, v)
    }
}

然后可以看看这个输出的结果，并留了一个为什么，不知道有木有朋友们思考到位了，咱们今天来合计合计这个问题。

map的结构分析

咱们初次接触GO的时候，已经被明确告知了，go语言中map是一个指针，必须要使用 make初始化之后才可以使用，咱们传递map的时候， 传递的也是map的这个指针，并不会复制map内部的数据内容，那么这个map的结构到底是如何的呢，这一块，在go源码的runtime\map.go中可以窥探一二，对于这一块的源码分析，网上也有比较详尽的资料可以查看。

不过由于Go在编译期间做了不少事情，比如编译的时候根据map类型来生成实际的map结构，填充里面的数据等，这一块实际上都是在编译期间做的，源码中并没有完整的包含这些，只是一个可以抽象出所有数据的一个外壳，所以，基础上比较薄弱，没有相应的知识的朋友们可能看起来比较糊涂，看完了，可能也是迷迷糊糊的，比如说，之前说过很多次的，go的字符串类型实际上是一个结构体，那么map得实际类型到底是个啥呢。

下面就来对map做一个一一对应的分解，并且将对应的数据结构，以及编译之后对应的数据类型一一地通过代码的形式分解出来。

map的实际类型

map的格式是指针，这是第一要素，那么我们首先第一步，直接先获取一下，map的内容大小,这个可以使用unsafe.Sizeof来获取到

前面我们说过string实际上是一个结构体如下

type StringData struct{
	Data        uintptr,
	DataLen     int,
}

所以，我们获取到string的数据长度是16，那么咱们来试试map的

func main() {
    var mp map[string]int
    if unsafe.Sizeof(mp) == unsafe.Sizeof(uintptr(0)) {
        pmp := unsafe.Pointer(&mp)
        fmt.Println("mp指向的map地址：", *(*int)(pmp))
        mp = make(map[string]int)
        fmt.Println("mp初始化之后指向的map地址：", *(*int)(pmp))
    } else {
        fmt.Println(unsafe.Sizeof(mp))
    }
}

我们先判定，mp是不是就是保存的就是一个map的地址值，如果就是一个地址值，那么就应该是和uintptr的大小一致，然后咱们取得这个mp的实际地址值，如果没有初始化，那么这个地址肯定是空，也就是0，然后make之后，肯定就有一个地址值了，通过这一个代码，我们就可以直接确定，在go语言中，咱们写的map变量中存放的实际上就是map的地址指针。

在上面获取map的实际地址值上是有一个技巧的，就是是通过取地址的地址，然后推导出来的结果，从而拿到了map实际的地址值，因为go的编译器限定了，又不能直接像C，C++等之类的语言，直接做强制转换，所以，只有拿到地址之后，用地址来做强制转换，这个就是指针类的好处了，获取了内存结构之后，指针就不在乎数据形式了，你想他是什么都行，只是内存中的一块数据而已。

解构map解构hmap

结合runtime中的map.go，我们可以知道，实际上map的结构就是hmap,所以呢，实际上，咱们在go代码中写的map，就是*hmap的指针值。那么咱么来解构一下，上面也说了，go由于编译器的限制不能直接强制转换，所以，咱们只有先获取地址，然后通过地址来转，那么go代码中的map实际上就是 *hmap,所以第一步取地址&mp获取到的实际上就是地址的地址也就是 **hmap，所以，然后解指针一下就可以获取到实际的结构了,首先，咱们将go的runtime/map.go中的hmap相关的结构拷贝进来，然后改造改造试下

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
}

const (
    // Maximum number of key/elem pairs a bucket can hold.
    bucketCntBits = 3
    bucketCnt     = 1 << bucketCntBits
)

type tflag uint8
type nameOff int32 // offset to a name
type typeOff int32 // offset to an *rtype

type rtype struct {
    size       uintptr
    ptrdata    uintptr // number of bytes in the type that can contain pointers
    hash       uint32  // hash of type; avoids computation in hash tables
    tflag      tflag   // extra type information flags
    align      uint8   // alignment of variable with this type
    fieldAlign uint8   // alignment of struct field with this type
    kind       uint8   // enumeration for C
    // function for comparing objects of this type
    // (ptr to object A, ptr to object B) -> ==?
    equal     func(unsafe.Pointer, unsafe.Pointer) bool
    gcdata    *byte   // garbage collection data
    str       nameOff // string form
    ptrToThis typeOff // type for pointer to this type, may be zero
}

type mapType struct {
    rtype
    key    *rtype // map key type
    elem   *rtype // map element (value) type
    bucket *rtype // internal bucket structure
    // function for hashing keys (ptr to key, seed) -> hash
    hasher     func(unsafe.Pointer, uintptr) uintptr
    keysize    uint8  // size of key slot
    valuesize  uint8  // size of value slot
    bucketsize uint16 // size of bucket
    flags      uint32
}

type emptyInterface struct {
    typ  *rtype
    word unsafe.Pointer
}

// PtrSize is the size of a pointer in bytes - unsafe.Sizeof(uintptr(0)) but as an ideal constant.
// It is also the size of the machine's native word size (that is, 4 on 32-bit systems, 8 on 64-bit).
const PtrSize = 4 << (^uintptr(0) >> 63)

// bucketShift returns 1<<b, optimized for code generation.
func bucketShift(b uint8) uintptr {
    // Masking the shift amount allows overflow checks to be elided.
    return uintptr(1) << (b & (PtrSize*8 - 1))
}

// bucketMask returns 1<<b - 1, optimized for code generation.
func bucketMask(b uint8) uintptr {
    return bucketShift(b) - 1
}

// 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
    //这下面是动态结构，是编译期间根据KV类型动态生成的,这里测试使用string类型
    keys     [8]string
    values   [8]string
    overflow uintptr
}

type hmap struct {
    // Note: the format of the hmap is also encoded in cmd/compile/internal/reflectdata/reflect.go.
    // Make sure this stays in sync with the compiler's definition.
    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)
    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 // optional fields
}

func main() {
	mp := make(map[string]string, 32)
	mp["tt"] = "tt"
	mp["tt1"] = "551"
	fmt.Println(unsafe.Sizeof(mp))
	var hmp *hmap
	hmp = *(**hmap)(unsafe.Pointer(&mp))
	fmt.Println("map的个数为：", hmp.count)
}

这里面改造的地方，只是在bmap结构中，将我们需要的类型补齐了，其他的没怎么变动

map的数据存储结构以及map的类型结构

map的本质实际上是一个哈希表，而对应的key不同，哈希函数肯定不同，同时，哈希表中存储的key,value的结构肯定也是动态的，但是runtime的map.go中只是给了一个通用的元素存储就结构bmap,而大家可以看到我上面的代码key是string,value也是string，所以在runtime/map.go的bmp的结构的基础上加上了keys [8]string和values [8]string以及overflow uintptr几个结构，这就说明了实际上这一块数据内容是在编译期间动态填充进去的，详细的内容，不细说了，网上有对应的说明，只标记一点，如果是别的类型，则这里对应的就是别的数据类型，同时针对每一个map结构，其都有一个mapType结构，记录了这个哈希表的类型结构

type mapType struct {
	rtype
	key    *rtype // map key type
	elem   *rtype // map element (value) type
	bucket *rtype // internal bucket structure
	// function for hashing keys (ptr to key, seed) -> hash
	hasher     func(unsafe.Pointer, uintptr) uintptr
	keysize    uint8  // size of key slot
	valuesize  uint8  // size of value slot
	bucketsize uint16 // size of bucket
	flags      uint32
}

这个结构中就记录了key类型，元素类型，以及哈希函数以及key大小，value大小，哈希桶大小等

查询方式

这一块，基本上就是是对 key 进行 hash 计算，计算后用 low bits 和高 8 位 hash 找到对应哈希桶的位置，然后再去桶中查找，这一块map.go中有，可以直接将相关代码搬出来，就行了，这里主要的代码要素是要找到这个key计算的哈希函数，而哈希函数在mapType中记录着，所以，最主要的就是找到map对应的mapType，给一个最简单的办法哈，就是用interface做一个中转，然后通过interface获取结构类型就可以搞定了，咱们可以写一个简单的查询某个key的值得代码如下

func main() {
    mp := make(map[string]string, 32)
    mp["tt"] = "tt"
    mp["tt1"] = "551"
    fmt.Println(unsafe.Sizeof(mp))
    var hmp *hmap
    hmp = *(**hmap)(unsafe.Pointer(&mp))
    fmt.Println("map的个数为：", hmp.count)
    //通过interface获取mapType结构，然后获取到他的hash函数
    var mpInterface interface{}
    mpInterface = mp
    eface := *(*emptyInterface)(unsafe.Pointer(&mpInterface))
    mpType := (*mapType)(unsafe.Pointer(eface.typ))
    fmt.Println("桶大小：", mpType.bucketsize)

    key := "tt"
    keyHash := mpType.hasher(unsafe.Pointer(&key), uintptr(hmp.hash0))
    m := bucketMask(hmp.B)
    bucketPointer := (*bmap)(unsafe.Pointer(uintptr(hmp.buckets) + (keyHash&m)*uintptr(mpType.bucketsize)))
    if bucketPointer != nil {
        //找到了桶了，直接从桶中查找
        for i := range bucketPointer.keys {
            if bucketPointer.keys[i] == key {
                fmt.Println("找到了key=", key, "的值为:", bucketPointer.values[i])
                break
            }
        }
    } else {
        //没有找到对应的桶,就从oldbuckets查找
    }
}

破题

通过上面这一系列的对应拆解，咱们再来看看最开始的那个问题是为啥子

1. 首先，存入到map的时候，实际上会先计算出一个key的hash值
2. 通过计算的哈希值，然后找到对应的哈希桶
3. 将键值数据存入到哈希桶中去

而如果咱们将已经存入了哈希表中的某个字符串key的地址的数据值改了，而此时key并不知道他的值改了，所以此时这个键值的位置不会变动，依然是在原先那个哈希桶。那么如果这个时候使用原来的字符串key访问，此时hash计算出来的结果和原结果一致，所以能找到对应的哈希桶，但是找到了哈希桶之后，比对哈希桶中的元素的key的时候，无法匹配，所以此时就找不到了。那么如果使用改变后的字符串key去访问map，此时如果计算出来的哈希值然后找到的哈希桶和原始哈希桶相同，那么就能够找到这个新值，如果计算出来的哈希桶和原始哈希桶不同，那么就肯定找不到这个值了。于是破题得证

附加

有网友，说最好加上一个能定位到同一个哈希桶内部查找到的修改实现方式，所以，就将代码调整了一下，加上了一个哈希碰撞的调整

func main() {
	mp := make(map[string]string, 32)
	mp["tt"] = "tt"
	mp["tt1"] = "551"
	fmt.Println(unsafe.Sizeof(mp))
	var hmp *hmap
	hmp = *(**hmap)(unsafe.Pointer(&mp))
	fmt.Println("map的个数为：", hmp.count)
	//通过interface获取mapType结构，然后获取到他的hash函数
	var mpInterface interface{}
	mpInterface = mp
	eface := *(*emptyInterface)(unsafe.Pointer(&mpInterface))
	mpType := (*mapType)(unsafe.Pointer(eface.typ))
	fmt.Println("桶大小：", mpType.bucketsize)

	key := "tt"
	keyHash := mpType.hasher(unsafe.Pointer(&key), uintptr(hmp.hash0))
	m := bucketMask(hmp.B)
	bucketPointer := (*bmap)(unsafe.Pointer(uintptr(hmp.buckets) + (keyHash&m)*uintptr(mpType.bucketsize)))
	if bucketPointer != nil {
		//找到了桶了，直接从桶中查找
		for i := range bucketPointer.keys {
			if bucketPointer.keys[i] == key {
				fmt.Println("找到了key=", key, "的值为:", bucketPointer.values[i])
				break
			}
		}
	} else {
		//没有找到对应的桶,就从oldbuckets查找

	}
	//下面来搞一个可以找到的
	buffer := []byte("test")
	stringData := reflect.StringHeader{
		Data: uintptr(unsafe.Pointer(&buffer[0])),
		Len:  len(buffer),
	}
	str := *(*string)(unsafe.Pointer(&stringData))

	mp[str] = str
	fmt.Println("原始key=" + str + ",value=" + mp[str])

	chars := []byte("abcdefghijklmnobjqrstuvwxyz")
	keyHash = mpType.hasher(unsafe.Pointer(&str), uintptr(hmp.hash0))
	bucketIndex := keyHash & m
	top := tophash(keyHash)
	for {
		buffer[0] = chars[rand.Intn(len(chars))]
		buffer[1] = chars[rand.Intn(len(chars))]
		buffer[2] = chars[rand.Intn(len(chars))]
		buffer[3] = chars[rand.Intn(len(chars))]
		newHash := mpType.hasher(unsafe.Pointer(&str), uintptr(hmp.hash0))
		if newHash&m == bucketIndex && tophash(newHash) == top {
			fmt.Println("碰撞到一个匹配到同一个哈希桶的key：", str)
			break
		}
	}

	keyHash = mpType.hasher(unsafe.Pointer(&str), uintptr(hmp.hash0))
	bucketPointer = (*bmap)(unsafe.Pointer(uintptr(hmp.buckets) + (keyHash&m)*uintptr(mpType.bucketsize)))
	if bucketPointer != nil {
		//找到了桶了，直接从桶中查找
		for i := range bucketPointer.keys {
			if bucketPointer.keys[i] == str {
				fmt.Println("通过自己实现的匹配模式,找到了key=", str, "的值为:", bucketPointer.values[i])
				break
			}
		}
	} else {
		//没有找到对应的桶,就从oldbuckets查找

	}
	fmt.Println("碰撞到的匹配的key=" + str + ",value=" + mp[str])
}

此时就行了。