type Mutex {
    state int32
    sema  uint32
}

32                                               3             2             1             0 
 |                                               |             |             |             | 
 |                                               |             |             |             | 
 v-----------------------------------------------v-------------v-------------v-------------+ 
 |                                               |             |             |             v 
 |                 waitersCount                  |mutexStarving| mutexWoken  | mutexLocked | 
 |                                               |             |             |             | 
 +-----------------------------------------------+-------------+-------------+-------------+                                                                                                              

type RWMutex struct {
	w           Mutex  // 復用互斥鎖
	writerSem   uint32 // 寫鎖監(jiān)聽讀鎖釋放的信號量
	readerSem   uint32 // 讀鎖監(jiān)聽寫鎖釋放的信號量
	readerCount int32  // 當前正在執(zhí)行讀操作的數(shù)量
	readerWait  int32  // 當寫操作被阻塞時，需要等待讀操作完成的個數(shù)
}

type Map struct {
	mu Mutex
	read atomic.Value // readOnly
	dirty map[interface{}]*entry
	misses int
}

// readOnly is an immutable struct stored atomically in the Map.read field.
type readOnly struct {
	m       map[interface{}]*entry
	amended bool // true if the dirty map contains some key not in m.
}

type entry struct {
	p unsafe.Pointer // *interface{}
}

//atomic.Value源碼

type Value struct {
	v interface{} // 所以可以存儲任何類型的數(shù)據(jù)
}

// 空 interface{} 的內(nèi)部表示格式，作用是將interface{}類型分解，得到其中兩個字段
type ifaceWords struct {
	typ  unsafe.Pointer
	data unsafe.Pointer
}

// 取數(shù)據(jù)就是正常走流程
func (v *Value) Load() (x interface{}) {
	vp := (*ifaceWords)(unsafe.Pointer(v))
	typ := LoadPointer(&vp.typ)
	if typ == nil || uintptr(typ) == ^uintptr(0) {
		// 第一次還沒寫入
		return nil
	}
  // 構(gòu)造新的interface{}返回出去
	data := LoadPointer(&vp.data)
	xp := (*ifaceWords)(unsafe.Pointer(&x))
	xp.typ = typ
	xp.data = data
	return
}

// 寫數(shù)據(jù)（如何保證數(shù)據(jù)完整性）
func (v *Value) Store(x interface{}) {
	if x == nil {
		panic("sync/atomic: store of nil value into Value")
	}
  // 繞過 Go 語言類型系統(tǒng)的檢查，與任意的指針類型互相轉(zhuǎn)換
	vp := (*ifaceWords)(unsafe.Pointer(v)) // 舊值
	xp := (*ifaceWords)(unsafe.Pointer(&x)) // 新值
	for { // 配合CompareAndSwap達到樂觀鎖的功效
		typ := LoadPointer(&vp.typ)
		if typ == nil { // 第一次寫入
			runtime_procPin() // 禁止搶占
			if !CompareAndSwapPointer(&vp.typ, nil, unsafe.Pointer(^uintptr(0))) {
				runtime_procUnpin() // 沒有搶到鎖，說明已經(jīng)有別的線程搶先完成賦值，重新進入循環(huán)
				continue
			}
			// 首次賦值
			StorePointer(&vp.data, xp.data)
			StorePointer(&vp.typ, xp.typ)
			runtime_procUnpin() // 寫入成功，解除占用狀態(tài)
			return
		}
		if uintptr(typ) == ^uintptr(0) {
			// 第一次寫入還未完成，繼續(xù)等待
			continue
		}
		// 兩次需要寫入相同類型
		if typ != xp.typ {
			panic("sync/atomic: store of inconsistently typed value into Value")
		}
		StorePointer(&vp.data, xp.data)
		return
	}
}

// 禁止搶占，標記當前G在M上不會被搶占，并返回當前所在P的ID。
func runtime_procPin()
// 解除G的禁止搶占狀態(tài)，之后G可被搶占。
func runtime_procUnpin()

var m sync.Mutex

func DoSth() {
    // do sth1
    func() {
       u.lock()
       defer m.unlock()
       // do sth2
    }() 
    // do sth3
}