kali锁屏后无法唤醒_Go语言 读写锁&互斥锁原理剖析(2)

1

1
type Mutex struct {  state int32  // 互斥锁上锁状态  sema  uint32 // 信号量}

1
> iota // 十进制：1，二进制：0001ntmutexWoken                        // 十进制：2，二进制：0010ntmutexStarving                     // 十进制：4，二进制：0100ntmutexWaiterShift      = iota      // 十进制：3，二进制：0011ntstarvationThresholdNs = 1e6       // 1e+06n)","classes":[]}"   >

1
const (  mutexLocked           = 1 << iota // 十进制：1，二进制：0001  mutexWoken                        // 十进制：2，二进制：0010  mutexStarving                     // 十进制：4，二进制：0100  mutexWaiterShift      = iota      // 十进制：3，二进制：0011  starvationThresholdNs = 1e6       // 1e+06)

1

1
func (m *Mutex) Lock() {  // ①CAS尝试获取锁，state为0表示没有协程持有锁，直接获得锁，将mutexLocked置为1。  // 如果设置成功，直接返回。如果获取锁失败会进入lockSlow方法进行自旋抢锁，直到抢到锁后返回。  if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {    if race.Enabled {      race.Acquire(unsafe.Pointer(m))    }    return  }  m.lockSlow()}

1
> mutexWaiterShiftntt}ntt// 6、切换到饥饿模式，解锁时不切换nttif starving && old&mutexLocked != 0 {ntttnew |= mutexStarvingntt}ntt// 7、唤醒nttif awoke {nttt// 8、互斥状态不相同就panicntttif new&mutexWoken == 0 {nttttthrow("sync: inconsistent mutex state")nttt}nttt// 同时把awoke位清掉ntttnew &^= mutexWokenntt}nnttif atomic.CompareAndSwapInt32(&m.state, old, new) {nttt// 9、old的第1位和第3位一定不是1，未锁定而且处于饥饿模式。获取锁成功ntttif old&(mutexLocked|mutexStarving) == 0 {nttttbreak // locked the mutex with CASnttt}nttt// 10、被唤醒的协程抢锁失败，重新放到队列首部ntttqueueLifo := waitStartTime != 0ntttif waitStartTime == 0 {nttttwaitStartTime = runtime_nanotime()nttt}nttt// 11、进入休眠状态，等待信号唤醒ntttruntime_SemacquireMutex(&m.sema, queueLifo, 1)nttt// 确认当前的锁的状态ntttstarving = starving || runtime_nanotime()-waitStartTime < starvationThresholdNsntttold = m.statentttif old&mutexStarving != 0 {ntttt// 12、饥饿模式不会出现mutex被锁住|唤醒，等待队列不能为0nttttif old&(mutexLocked|mutexWoken) != 0 || old<>mutexWaiterShift)ntttt// 非饥饿模式，等待者只有一个时，退出饥饿模式nttttif !starving || old<

1
func (m *Mutex) lockSlow() {  var waitStartTime int64 // 协程等待时间  starving := false       // 锁的模式  awoke := false          // 循环标记  iter := 0               // 计数器  old := m.state          // 当前的锁状态  for {    // 1、old&0101==0001等于1说明已经加过锁，(old第1位一定是1，第3位一定是0)这时候未处于饥饿模式，开始自旋。    if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {      // 2、当前协程未能成功更新mutexWoken位，mutexWoken位仍然为0，等待队列为空，更新mutexWoken成功开始自旋。      if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&        atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {        awoke = true      }      // 3、将当前的协程标识为唤醒状态后，执行自旋操作，计数器+1，当前状态更新到old。      runtime_doSpin()      iter++      old = m.state      continue    }    new := old    // 4、新到的协程第三位等于0为正常模式需要排除    if old&mutexStarving == 0 {      new |= mutexLocked    }    // 5、当old的1和3位为1时，为饥饿模式，需要去排队    if old&(mutexLocked|mutexStarving) != 0 {      new += 1 << mutexWaiterShift    }    // 6、切换到饥饿模式，解锁时不切换    if starving && old&mutexLocked != 0 {      new |= mutexStarving    }    // 7、唤醒    if awoke {      // 8、互斥状态不相同就panic      if new&mutexWoken == 0 {        throw("sync: inconsistent mutex state")      }      // 同时把awoke位清掉      new &^= mutexWoken    }    if atomic.CompareAndSwapInt32(&m.state, old, new) {      // 9、old的第1位和第3位一定不是1，未锁定而且处于饥饿模式。获取锁成功      if old&(mutexLocked|mutexStarving) == 0 {        break // locked the mutex with CAS      }      // 10、被唤醒的协程抢锁失败，重新放到队列首部      queueLifo := waitStartTime != 0      if waitStartTime == 0 {        waitStartTime = runtime_nanotime()      }      // 11、进入休眠状态，等待信号唤醒      runtime_SemacquireMutex(&m.sema, queueLifo, 1)      // 确认当前的锁的状态      starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs      old = m.state      if old&mutexStarving != 0 {        // 12、饥饿模式不会出现mutex被锁住|唤醒，等待队列不能为0        if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {          throw("sync: inconsistent mutex state")        }        // 13、拿到锁，等待数-1        delta := int32(mutexLocked - 1<        // 非饥饿模式，等待者只有一个时，退出饥饿模式        if !starving || old>>mutexWaiterShift == 1 {          delta -= mutexStarving        }        // 14、更新状态，高位原子计数，直接添加        atomic.AddInt32(&m.state, delta)        break      }      // 15、awoke=true，不处于饥饿模式，新到达的协程先获得锁      awoke = true      iter = 0    } else {      // 16、old = m.state，自旋没成功，更新new，记录当前的状态      old = m.state    }  }  if race.Enabled {    race.Acquire(unsafe.Pointer(m))  }}

1

1
func (m *Mutex) Unlock() {  if race.Enabled {    _ = m.state    race.Release(unsafe.Pointer(m))  }  // 直接更新第一位即锁位置为0，直接解锁  new := atomic.AddInt32(&m.state, -mutexLocked)  if new != 0 {    m.unlockSlow(new)  }}

1
>mutexWaiterShift) | mutexWokenntttif atomic.CompareAndSwapInt32(&m.state, old, new) {ntttt// 唤醒一个阻塞的协程，唤醒的不是第一个等待协程nttttruntime_Semrelease(&m.sema, false, 1)nttttreturnnttt}ntttold = m.statentt}nt} else {ntt// ④饥饿模式下，将持有锁交给下一个等待者，此时mutexLocked还为0，但是在饥饿模式下，新协程不会更新mutexLocked位。nttruntime_Semrelease(&m.sema, true, 1)nt}n}n","classes":[]}"   >

1
func (m *Mutex) unlockSlow(new int32) {  // ①状态不一致，直接抛异常  if (new+mutexLocked)&mutexLocked == 0 {    throw("sync: unlock of unlocked mutex")  }  // ②饥饿模式直接唤醒队列首部的协程  if new&mutexStarving == 0 {    old := new    for {      // ③如果没有等待者或协程，不用唤醒就返回      if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {        return      }      // 等待者数量-1，将唤醒位改成1      new = (old - 1<      if atomic.CompareAndSwapInt32(&m.state, old, new) {        // 唤醒一个阻塞的协程，唤醒的不是第一个等待协程        runtime_Semrelease(&m.sema, false, 1)        return      }      old = m.state    }  } else {    // ④饥饿模式下，将持有锁交给下一个等待者，此时mutexLocked还为0，但是在饥饿模式下，新协程不会更新mutexLocked位。    runtime_Semrelease(&m.sema, true, 1)  }}