Golang 互斥锁内部实现

type Mutex struct {
	state int32 //互斥锁上锁状态枚举值如下所示
	sema uint32 //信号量,向处于Gwaitting的G发送信号
}
const (
	mutexLocked = 1 << iota // 1 互斥锁是锁定的
	mutexWoken // 2 唤醒锁
	mutexWaiterShift = iota // 2 统计阻塞在这个互斥锁上的goroutine数目需要移位的数值
)

//go:linkname sync_runtime_canSpin sync.runtime_canSpin
func sync_runtime_canSpin(i int) bool {
	if i >= active_spin || ncpu <= 1 || gomaxprocs <= int32(sched.npidle+sched.nmspinning)+1 {
		return false
	}
	if p := getg().m.p.ptr(); !runqempty(p) {
		return false
	}
	return true
}

//go:linkname sync_runtime_doSpin sync.runtime_doSpin
func sync_runtime_doSpin() {
	procyield(active_spin_cnt)
}

//go:linkname sync_runtime_SemacquireMutex sync.runtime_SemacquireMutex
func sync_runtime_SemacquireMutex(addr *uint32) {
	semacquire(addr, semaBlockProfile|semaMutexProfile)
}

//go:linkname sync_runtime_Semrelease sync.runtime_Semrelease
func sync_runtime_Semrelease(addr *uint32) {
	semrelease(addr)
}

func (m *Mutex) Lock() {
 //先使用CAS尝试获取锁
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
 //这里是-race不需要管它
		if race.Enabled {
			race.Acquire(unsafe.Pointer(m))
		}
 //成功获取返回
		return
	}
	awoke := false //循环标记
	iter := 0 //循环计数器
	for {
		old := m.state //获取当前锁状态
		new := old | mutexLocked //将当前状态最后一位指定1
		if old&mutexLocked != 0 { //如果所以被占用
			if runtime_canSpin(iter) { //检查是否可以进入自旋锁
				if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
					atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) { 
 //awoke标记为true
					awoke = true
				}
 //进入自旋状态
				runtime_doSpin()
				iter++
				continue
			}
 //没有获取到锁,当前G进入Gwaitting状态
			new = old + 1<<mutexWaiterShift
		}
		if awoke {
			if new&mutexWoken == 0 {
				throw("sync: inconsistent mutex state")
			}
 //清除标记
			new &^= mutexWoken
		}
 //更新状态
		if atomic.CompareAndSwapInt32(&m.state, old, new) {
			if old&mutexLocked == 0 {
				break
			}
 
 // 锁请求失败,进入休眠状态,等待信号唤醒后重新开始循环
			runtime_SemacquireMutex(&m.sema)
			awoke = true
			iter = 0
		}
	}
	if race.Enabled {
		race.Acquire(unsafe.Pointer(m))
	}
}

func (m *Mutex) Unlock() {
	if race.Enabled {
		_ = m.state
		race.Release(unsafe.Pointer(m))
	}
	// 移除标记
	new := atomic.AddInt32(&m.state, -mutexLocked)
	if (new+mutexLocked)&mutexLocked == 0 {
		throw("sync: unlock of unlocked mutex")
	}
	old := new
	for {
		//当休眠队列内的等待计数为0或者自旋状态计数器为0,退出
		if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {
			return
		}
		// 减少等待次数,添加清除标记
		new = (old - 1<<mutexWaiterShift) | mutexWoken
		if atomic.CompareAndSwapInt32(&m.state, old, new) {
 // 释放锁,发送释放信号
			runtime_Semrelease(&m.sema)
			return
		}
		old = m.state
	}
}

有疑问加站长微信联系(非本文作者)

• 请尽量让自己的回复能够对别人有帮助
• 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
• 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
• 图片支持拖拽、截图粘贴等方式上传