互斥锁Mutex
应用锁爱护共享资源
Locker()是一个interface。
type Locker interface { Lock() Unlock()}mutex构造体
type Mutex struct { state int32 sema uint32}state:
state 是一个复合型的字段，一个字段蕴含多个意义，这样能够通过尽可能少的内存来实现
互斥锁。这个字段的第一位（最小的一位）来示意这个锁是否被持有，第二位代表是否有
唤醒的 goroutine，第三位代表锁开释处于饥饿状态，残余的位数代表的是期待此锁的 goroutine 数。
sema:
sema是个信号量变量，用来管制期待 goroutine 的阻塞休眠和唤醒。
Lock()
Mutex 能够处于 2 种操作模式：失常模式和饥饿模式。
在失常模式下，waiters按 FIFO 程序排队，然而被唤醒的waiters不领有mutex并与新达到的 goroutines 竞争mutex所有权。新达到的 goroutine 有一个劣势——它们是曾经在 CPU 上运行并且可能有很多，所以被唤醒waiter可能会失败。在这种状况下，唤醒的waiter会在排在期待队列的后面。如果waiter超过 1ms 未能获取mutex，它将mutex切换到饥饿模式。
在饥饿模式下，mutex的所有权间接从解锁 goroutine 移交给队列后面的waiter。
新达到的 goroutine 不会尝试获取互斥锁，即便它看起来已解锁，也不会尝试自旋。相同，他们将本人排在期待队列的尾部。
如果waiter收到mutex的所有权并看到
(1) 它是队列中的最初一个期待者(2) 它期待的工夫不到 1ms，它将互斥锁切换回失常操作模式。
失常模式具备更好的性能，因为即便有阻塞的waiter，goroutine 能够间断屡次取得mutex。
饥饿模式对于避免尾部提早的病理状况很重要。
func (m *Mutex) Lock() { // Fast path: grab unlocked mutex. // cas获取到锁 if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) { if race.Enabled { race.Acquire(unsafe.Pointer(m)) } return } // Slow path (outlined so that the fast path can be inlined) // 尝试自旋竞争或饥饿状态下饥饿goroutine竞争 m.lockSlow()}func (m *Mutex) lockSlow() { // 记录此 goroutine 申请锁的初始工夫 var waitStartTime int64 // 此goroutine的饥饿标记 starving := false // 唤醒标记 awoke := false // 自旋次数 iter := 0 // 以后锁的状态 old := m.state for { // Don't spin in starvation mode, ownership is handed off to waiters // so we won't be able to acquire the mutex anyway. // 锁是非饥饿状态，锁未开释，自旋尝试获取锁 // 如果无奈间接获取锁，进行屡次自旋尝试;屡次尝试失败，进入sema队列休眠 if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) { // Active spinning makes sense. // Try to set mutexWoken flag to inform Unlock // to not wake other blocked goroutines. // 尝试设置 mutexWoken 标记以告诉 Unlock 不要唤醒其余阻塞的 goroutine。 if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 && atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) { awoke = true } runtime_doSpin() iter++ // 再次获取锁的状态，之后会查看是否锁被开释了 old = m.state continue } new := old // Don't try to acquire starving mutex, new arriving goroutines must queue. // 不要尝试获取饥饿的互斥锁，新达到的 goroutine 必须排队。 if old&mutexStarving == 0 { // 非饥饿状态，加锁 new |= mutexLocked } if old&(mutexLocked|mutexStarving) != 0 { // waiter数量加1 new += 1 << mutexWaiterShift } // The current goroutine switches mutex to starvation mode. // But if the mutex is currently unlocked, don't do the switch. // Unlock expects that starving mutex has waiters, which will not // be true in this case. // 以后的 goroutine 将 mutex 切换到饥饿模式。 if starving && old&mutexLocked != 0 { // 设置饥饿状态 new |= mutexStarving } if awoke { // The goroutine has been woken from sleep, // so we need to reset the flag in either case. // goroutine 曾经从睡眠中唤醒， // 所以咱们须要在任何一种状况下重置标记。 if new&mutexWoken == 0 { throw("sync: inconsistent mutex state") } // 新状态革除唤醒标记 new &^= mutexWoken } // cas胜利设置新状态 if atomic.CompareAndSwapInt32(&m.state, old, new) { // 原来锁的状态已开释，并且不是饥饿状态，失常申请到了锁，返回 if old&(mutexLocked|mutexStarving) == 0 { break // locked the mutex with CAS } // If we were already waiting before, queue at the front of the queue. // 如果咱们之前曾经在期待，请在队列的后面排队。 // 判断是否第一次退出到 waiter 队列 queueLifo := waitStartTime != 0 if waitStartTime == 0 { waitStartTime = runtime_nanotime() } // 阻塞期待 // 将此 waiter 退出到队列，如果是首次，退出到队尾，先进先出。如果不是首次，那么退出到队首，这样期待最久的 goroutine 优先可能获取到锁。此 goroutine 会进行休眠。 runtime_SemacquireMutex(&m.sema, queueLifo, 1) // 唤醒之后查看锁是否应该处于饥饿状态,此时曾经被唤醒 // 查看等待时间是否大于1ms starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs old = m.state // 如果锁曾经处于饥饿状态，间接抢到锁，返回 if old&mutexStarving != 0 { // If this goroutine was woken and mutex is in starvation mode, // ownership was handed off to us but mutex is in somewhat // inconsistent state: mutexLocked is not set and we are still // accounted as waiter. Fix that. if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 { throw("sync: inconsistent mutex state") } // 加锁,waiter数减1 delta := int32(mutexLocked - 1<<mutexWaiterShift) if !starving || old>>mutexWaiterShift == 1 { // Exit starvation mode. // Critical to do it here and consider wait time. // Starvation mode is so inefficient, that two goroutines // can go lock-step infinitely once they switch mutex // to starvation mode. // 退出饥饿模式。 // 此 waiter 曾经是队列中的最初一个 waiter 了，没有其它的期待锁的 goroutine 了； // 此 waiter 的等待时间小于 1 毫秒。 delta -= mutexStarving } atomic.AddInt32(&m.state, delta) break } awoke = true iter = 0 } else { old = m.state } } if race.Enabled { race.Acquire(unsafe.Pointer(m)) }}Unlock()
func (m *Mutex) Unlock() { if race.Enabled { _ = m.state race.Release(unsafe.Pointer(m)) } // Fast path: drop lock bit. new := atomic.AddInt32(&m.state, -mutexLocked) if new != 0 { // Outlined slow path to allow inlining the fast path. // To hide unlockSlow during tracing we skip one extra frame when tracing GoUnblock. m.unlockSlow(new) }}func (m *Mutex) unlockSlow(new int32) { if (new+mutexLocked)&mutexLocked == 0 { fatal("sync: unlock of unlocked mutex") } if new&mutexStarving == 0 { old := new for { // If there are no waiters or a goroutine has already // been woken or grabbed the lock, no need to wake anyone. // In starvation mode ownership is directly handed off from unlocking // goroutine to the next waiter. We are not part of this chain, // since we did not observe mutexStarving when we unlocked the mutex above. // So get off the way. // 如果 Mutex 处于失常状态，如果没有 waiter，或者曾经有在解决的状况了，那么开释就好，不做额定的解决。 if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 { return } // Grab the right to wake someone. // waiter 数减 1，设置mutexWoken 标记,通过 CAS 更新 state 的值。 new = (old - 1<<mutexWaiterShift) | mutexWoken if atomic.CompareAndSwapInt32(&m.state, old, new) { runtime_Semrelease(&m.sema, false, 1) return } old = m.state } } else { // Starving mode: handoff mutex ownership to the next waiter, and yield // our time slice so that the next waiter can start to run immediately. // Note: mutexLocked is not set, the waiter will set it after wakeup. // But mutex is still considered locked if mutexStarving is set, // so new coming goroutines won't acquire it. // 如果 Mutex 处于饥饿状态，间接唤醒期待队列中的 waiter。 runtime_Semrelease(&m.sema, true, 1) }}TryLock()
当一个 goroutine 调用这个TryLock 办法申请锁的时候，如果这把锁没有被其余 goroutine 所持有，那么，这个goroutine 就持有了这把锁，并返回 true；如果这把锁曾经被其余 goroutine 所持有，或者是正在筹备交给某个被唤醒的 goroutine，那么，这个申请锁的 goroutine 就间接返回
false，不会阻塞在办法调用上。
func (m *Mutex) TryLock() bool { old := m.state if old&(mutexLocked|mutexStarving) != 0 { return false } // There may be a goroutine waiting for the mutex, but we are // running now and can try to grab the mutex before that // goroutine wakes up. if !atomic.CompareAndSwapInt32(&m.state, old, old|mutexLocked) { return false } if race.Enabled { race.Acquire(unsafe.Pointer(m)) } return true}