重點

在上篇文章《go基礎之map-增和改（二）》已經非常詳細的描述了定位key所在的桶以及它所在桶的位置，如果對上篇有所了解之后，該偏博客理解起來就會非常容易，總的來說map的洗掉主要做了2件事：

1. 定位key所在的位置，并且洗掉key，清除value的記憶體資料；
2. 嘗試標記該key所在桶里面的元素為emptyRest，如果該桶處在逸出桶，那么就嘗試向前遍歷桶的元素為emptyRest，

如果想詳細查看原始碼的注釋，可以查看我的GitHub,歡迎批評指正，我的打算是把一些常用的資料結構都分析一遍，如果有志同道合的人，可以聯系我，

詳細決議

前面系列的文章如果有所了解的話，那這篇文章我就按照重點決議原始碼了，主要是思路，其實洗掉算是該map最簡單的一個操作了，首先說明下map洗掉的底層代碼是mapdelete_faststr方法，在runtime/map_faststr.go里面，話不多說上碼，

func mapdelete_faststr(t *maptype, h *hmap, ky string) {
	if raceenabled && h != nil {
		callerpc := getcallerpc()
		racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapdelete_faststr))
	}
	if h == nil || h.count == 0 {
		return
	}
	if h.flags&hashWriting != 0 {
		throw("concurrent map writes")
	}

	key := stringStructOf(&ky)
	hash := t.hasher(noescape(unsafe.Pointer(&ky)), uintptr(h.hash0))

	// Set hashWriting after calling t.hasher for consistency with mapdelete
	h.flags ^= hashWriting

	bucket := hash & bucketMask(h.B)
	// 順便遷移
	if h.growing() {
		growWork_faststr(t, h, bucket)
	}
	// 找到key所在的桶
	b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
	// 記錄下剛開始key的所在的桶
	bOrig := b
	top := tophash(hash)
	....
}

上面代碼就是找到洗掉的key所在的桶的編號，然后還順便嘗試遷移一波，bOrig記錄了這個bucket的序號，下面去標記tophash槽的狀態有用，

...
search:
	// 外層回圈該key所在的桶以及桶后面的逸出桶
	for ; b != nil; b = b.overflow(t) {
		// 遍歷桶的資料
		for i, kptr := uintptr(0), b.keys(); i < bucketCnt; i, kptr = i+1, add(kptr, 2*sys.PtrSize) {
			k := (*stringStruct)(kptr)
			if k.len != key.len || b.tophash[i] != top {
				continue
			}
			if k.str != key.str && !memequal(k.str, key.str, uintptr(key.len)) {
				continue
			}
			// Clear key's pointer.
			// 清除key的字符，把長度留下
			k.str = nil
			e := add(unsafe.Pointer(b), dataOffset+bucketCnt*2*sys.PtrSize+i*uintptr(t.elemsize))
			// 清除value的記憶體
			if t.elem.ptrdata != 0 {
				memclrHasPointers(e, t.elem.size)
			} else {
				memclrNoHeapPointers(e, t.elem.size)
			}
			// 標記為值已經被清除
			b.tophash[i] = emptyOne
			// If the bucket now ends in a bunch of emptyOne states,
			// change those to emptyRest states.
			// 判斷該所在桶的key后面的key是否都已經被清空
			// 或者如果該key已經是桶內的第8個key，那么就判斷該桶的所有逸出桶是否已經被清空
			if i == bucketCnt-1 {
				if b.overflow(t) != nil && b.overflow(t).tophash[0] != emptyRest {
					goto notLast
				}
			} else {
				if b.tophash[i+1] != emptyRest {
					goto notLast
				}
			}
			// 往前面一直去試圖示記桶的hash槽為emptyRest狀態
			// 當該槽的狀態為emptyRest之后，那么就是該key之后所有的槽，以及該桶后面的逸出桶都是emptyRest
			for {
				b.tophash[i] = emptyRest
				if i == 0 {
					if b == bOrig {
						break // beginning of initial bucket, we're done.
					}
					// Find previous bucket, continue at its last entry.
					c := b
					// 去找該桶的前一個桶
					for b = bOrig; b.overflow(t) != c; b = b.overflow(t) {
					}
					i = bucketCnt - 1
				} else {
					i--
				}
				// 如果是emptyOne，也就是被洗掉了，那么就標記為emptyRest
				if b.tophash[i] != emptyOne {
					break
				}
			}
		notLast:
			h.count--
			break search
		}
	}

	if h.flags&hashWriting == 0 {
		throw("concurrent map writes")
	}
	h.flags &^= hashWriting

相信看了前面《go基礎之map-增和改（二）》 之后，對上段代碼的2個for回圈相當熟悉，就是找到key和value的記憶體地址，有幾個地方分析下:

1. 14-16行，可以看到只是把key的字符指標清除掉了，但是長度并沒有被清除掉，為什么這么做呢？又知道的在下面留言探討，我覺得這樣并沒有什么意義，對map的其他操作沒任何影響，
2. 17~23行，清除了value的記憶體，可以看到元素里面有指標和沒指標完全是2種清理方式，
3. 25行b.tophash[i] = emptyOne標記該tophash槽為emptyOne狀態，這里說說tophash槽的幾個狀態:

   // Possible tophash values. We reserve a few possibilities for special marks.
   // Each bucket (including its overflow buckets, if any) will have either all or none of its
   // entries in the evacuated* states (except during the evacuate() method, which only happens
   // during map writes and thus no one else can observe the map during that time).
   emptyRest      = 0 // this cell is empty, and there are no more non-empty cells at higher indexes or overflows.
   emptyOne       = 1 // this cell is empty
   evacuatedX     = 2 // key/elem is valid.  Entry has been evacuated to first half of larger table.
   evacuatedY     = 3 // same as above, but evacuated to second half of larger table.
   evacuatedEmpty = 4 // cell is empty, bucket is evacuated.
   minTopHash     = 5 // minimum tophash for a normal filled cell.
   

   ①、emptyRest表示該槽之后的槽都沒有key，并且該槽所在的桶后面的溢位桶也沒有資料，
   ②、emptyOne表示該槽已經被清空了，
   ③、evacuatedX，evacuatedY表示該key已經被遷移過了，evacuatedX表示該桶的資料被遷移到序號低的桶，evacuatedY表示該桶被遷移到序號比較高的桶，具體可以看我在《go基礎之map-增和改（二）》的分析，這個標記在迭代的時候會用到，后面序列博客會介紹，
   ④、evacuatedEmpty表示該tophash槽已經被遷移了，并且該tophash所在的桶也搬完了，
   ⑤、minTopHash表示最小的tophash值了，當一個key計算出來的tophash比這個還小的話就要加上minTopHash作為最終的tophash，
4. 26~38行的意思是判斷要不要去嘗試標記該桶之前的資料為emptyRest，i == bucketCnt-1表示這個key已經是桶的最后的資料了，就要去看看該桶的溢位桶是否是emptyRest,如果是那么就可以標記當前槽為emptyRest,并且向前嘗試去標記前面的槽，如果不是最后一個桶，那么就判斷該key后面一個資料是否是emptyRest，
5. 39~60行就是滿足了上面的條件之后，就會來嘗試標記桶的資料為emptyRest，這里就用到了上面提到的bOrig，不斷的向前面找桶的key是否是emptyOne，如果是就標為emptyRest，第50行代碼是防止洗掉的key在溢位桶的時候，就要順著溢位桶往前面找所有的桶，嘗試標記，

然后就完了？納尼，當我寫完這篇博客我才發現如此的簡單，并且出現了一個疑問：當在擴容的時候，如果這個key在老桶上面，豈不是就不洗掉了？然后我回去再縷了下原始碼，發現了有段代碼略過了:

	// 順便遷移
	if h.growing() {
		growWork_faststr(t, h, bucket)
	}

這里會去嘗試遷移遷移的老桶，遷移完成之后接下來再去查找洗掉的key，好，疑問解決，

總結

洗掉比較簡單，但是要完全能理明白的話或許要看《go基礎之map-增和改（二）》打些基礎，如有不足之處，請共同討論學習，