Golang的鎖機制與使用技巧小結

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 // 寫鎖監聽讀鎖釋放的號誌
	readerSem   uint32 // 讀鎖監聽寫鎖釋放的號誌
	readerCount int32  // 當前正在執行讀操作的數量
	readerWait  int32  // 當寫操作被阻塞時，需要等待讀操作完成的個數
}

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{} // 所以可以儲存任何型別的資料
}

// 空 interface{} 的內部表示格式，作用是將interface{}型別分解，得到其中兩個欄位
type ifaceWords struct {
	typ  unsafe.Pointer
	data unsafe.Pointer
}

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

// 寫資料（如何保證資料完整性）
func (v *Value) Store(x interface{}) {
	if x == nil {
		panic("sync/atomic: store of nil value into Value")
	}
  // 繞過 Go 語言型別系統的檢查，與任意的指標型別互相轉換
	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() // 沒有搶到鎖，說明已經有別的執行緒搶先完成賦值，重新進入迴圈
				continue
			}
			// 首次賦值
			StorePointer(&vp.data, xp.data)
			StorePointer(&vp.typ, xp.typ)
			runtime_procUnpin() // 寫入成功，解除佔用狀態
			return
		}
		if uintptr(typ) == ^uintptr(0) {
			// 第一次寫入還未完成，繼續等待
			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的禁止搶佔狀態，之後G可被搶佔。
func runtime_procUnpin()

var m sync.Mutex

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