Golang Mutex互斥锁源码分析

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


const (
 mutexLocked = 1 << iota // 1
 mutexWoken // 2
 mutexStarving // 4
 mutexWaiterShift = iota // 3

 starvationThresholdNs = 1e6 // 判断是否要进入饥饿状态的阈值
)

// 上锁
func (m *Mutex) Lock() {
 // fastpath：期望当前锁没有被占用，可以快速获取到锁， CAS 修改 state 最后一位的值为1（标记锁是否被占用）
 if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
  return
 }
 // Slow path : 单独抽出来放到一个函数里，方便 fast path 被内联
 m.lockSlow()
}

func (m *Mutex) lockSlow() {
 var waitStartTime int64 // // 记录等待时间
 starving := false // 当前的 goroutine 是否已经饥饿了（如果已经饥饿，就会将 state 的饥饿状态置为 1）
 awoke := false  // 当前的 goroutine 是否被唤醒的
 iter := 0 // 自旋次数
 old := m.state // 保存当前的 state 状态
 for {
    
    
  if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
   
      

   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 代表当前goroutine 基于当前状态要设置的新状态
  new := old
    
    // 只要不是饥饿状态，就需要获取锁（饥饿状态直接去排队，不能抢锁）
  if old&mutexStarving == 0 {
   new |= mutexLocked
  }
    
    // 锁被占用 或者 处于饥饿模式下，新增一个等待者
  if old&(mutexLocked|mutexStarving) != 0 {
   new += 1 << mutexWaiterShift
  }
    
    // 当前 goroutine 已经进入饥饿了，且锁还没有释放，需要把 Mutex 的状态改为饥饿状态
  if starving && old&mutexLocked != 0 {
   new |= mutexStarving
  }
    
    // 如果是被唤醒的，把唤醒标志位置0，表示外面没有被唤醒的goroutine了（抢到就获得锁、抢不到就睡眠，把唤醒标志置0）
  if awoke {
   
      // 由于是被唤醒的，new 里面的 唤醒标记位一定是 1
   if new&mutexWoken == 0 {
    throw("sync: inconsistent mutex state")
   }
      
      // a &^ b 的意思就是 清零a中，ab都为1的位，即清除唤醒标记
   new &^= mutexWoken
  }
    
    
    
  if atomic.CompareAndSwapInt32(&m.state, old, new) {
      
      // 如果改状态之前，锁未被占用 且 处于正常模式，那么就相当于获取到锁了
   if old&(mutexLocked|mutexStarving) == 0 {
    break 
   }
      
      // 到这里说明：1. 之前锁被占用  或者 2.之前是处于饥饿状态 
      
      // 判断之前是否等待过（是否从队列里唤醒的），之前等待过，再次排队放在队首
   queueLifo := waitStartTime != 0
      
      // 如果之前没等过（新来的），设置等待起始时间当前时间
   if waitStartTime == 0 {
    waitStartTime = runtime_nanotime()
   }
      
     // 之前排过队的老人，放到等待队列队首；新人放到队尾，然后等待获取信号量
   runtime_SeMacquireMutex(&m.sema, queueLifo, 1)
      
      // 锁被释放，goroutine 被唤醒
      
      // 设置当前 goroutine 饥饿状态，如果之前已经饥饿，或者距离等待开始时间超过了 1ms，也变饥饿
   starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
      
      // 获取最新的状态
   old = m.state
      
      // 如果 state 饥饿标记为1，说明当前在饥饿模式，饥饿模式下被唤醒，已经获取到锁了；
      // 饥饿状态下，释放锁没有更新等待者数量和饥饿标记，需要获得锁的goroutine去更新状态
   if old&mutexStarving != 0 {

        // 正确性校验：
        // 1. 锁还是锁住的状态（锁已经释放给当前goroutine了，不应该被锁住）
    // 2. 或者有被唤醒的goroutine（饥饿模式下不应该有醒着的goroutine，都应该去乖乖等着）
    // 3. 或者当前goroutine 的等待者数量为0（当前goroutine就是等待者）
    // 这三种情况不应该出现，与预期状态不符
        
    if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
     throw("sync: inconsistent mutex state")
    }
        
        // 加锁，减去一个等待者
    delta := int32(mutexLocked - 1<<mutexWaiterShift)
        
        // 如果当前的 goroutine 非饥饿，或者等待者只有一个（也就是只有当前goroutine，等待队列空了），可以取消饥饿状态，进入正常状态
    if !starving || old>>mutexWaiterShift == 1 {
     delta -= mutexStarving
    }
        
        // 修改状态：
        // 加锁，减去一个等待者：m.state + mutexLocked - 1<<mutexWaiterShift : 
        // 满足非饥饿条件，加锁，减去一个等待者，取消饥饿状态：
        // m.state + mutexLocked - 1<<mutexWaiterShift - mutexStarving: 
    atomic.AddInt32(&m.state, delta)
        
        // 饥饿模式下被唤醒，相当于获得锁了，可以结束
    break
   }
      
      // 之前是处于锁被占用且非饥饿状态，被唤醒，去继续抢锁
   awoke = true
      
      // 新唤醒的，自旋数量置0
   iter = 0
  } else {
      
      // 修改新状态失败，状态有更新，需要重试
   old = m.state
  }
 }
}

func (m *Mutex) Unlock() {

 // Fast path: 把锁标记清除
 new := atomic.AddInt32(&m.state, -mutexLocked)
 if new != 0 {
  // 清除完锁标记，发现还有其他状态，比如等待队列不为空，需要唤醒其他 goroutine
  m.unlockSlow(new)
 }
}

func (m *Mutex) unlockSlow(new int32) {
  
  
 if (new+mutexLocked)&mutexLocked == 0 {
  throw("sync: unlock of unlocked mutex")
 }
  
  // 正常模式，非饥饿，可能需要唤醒队列中的 goroutine，饥饿状态直接移交锁
 if new&mutexStarving == 0 {
  old := new
  for {

      
   if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
    return
   }
      
      // 没有唤醒状态的 goroutine，唤醒一个去抢锁
   // 减去一个等待者，并且将 唤醒标记 置为 1
   new = (old - 1<<mutexWaiterShift) | mutexWoken
   if atomic.CompareAndSwapInt32(&m.state, old, new) {
        // 第二个参数为false, 唤醒队首的 goroutine 去抢锁(不一定能抢到)
    runtime_Semrelease(&m.sema, false, 1)
    return
   }
      
      // 上面 CAS 失败，可能由于新增了一个等待者，for 循环重试
   old = m.state
  }
 } else {
  
    
  runtime_Semrelease(&m.sema, true, 1)
 }
}