听说Mutex源码是出名的不好看，我不信，来试一下

type Mutex struct {
  key int32
  sema int32
}

type Mutex struct {
  state int32
  sema uint32
}

func (m *Mutex) Lock() {
  // Fast path
 if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
  if race.Enabled {
   race.Acquire(unsafe.Pointer(m))
  }
  return
 }
  // slow path
 m.lockSlow()
}

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 {
    // Slow path
  m.unlockSlow(new)
 }
}

type Mutex struct {
 state int32
 sema  uint32
}

type Locker interface {
 Lock()
 Unlock()
}

const (
 mutexLocked = 1 << iota // mutex is locked
 mutexWoken
 mutexStarving
 mutexWaiterShift = iota
 starvationThresholdNs = 1e6
)

func (m *Mutex) Lock() {
 if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
  if race.Enabled {
   race.Acquire(unsafe.Pointer(m))
  }
  return
 }
 m.lockSlow()
}

func (m *Mutex) lockSlow() {
 var waitStartTime int64
 starving := false
 awoke := false
 iter := 0
 old := m.state

 // 加锁时，会有多个协程会同时来抢Mutex，CAS操作可以保证原子性，如果一个协程修改了Mutex状态后还抢锁失败，
 // 需要重新去抢锁，所以这里用大for循环把逻辑包起来。
 for {
  // 这个if循环主要判断waiter是否可以自旋，自旋条件不满足时，会执行下段代码
  // old&(mutexLocked|mutexStarving) == mutexLocked 这段代码是看old是否处于饥饿状态，饥饿状态没必要自旋
  // 锁释放了，或者处于饥饿状态，或者自旋次数够了，就不再自旋了
  if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
   // 设置 mutexWoken 标记，这里貌似和下面Unlock的代码有联动
   // 这里是为了告知持有锁的goroutine在释放锁时不需要唤醒其他goroutine了，已经有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
  }

  // 下面四个if判断分别用于对3种状态和一个数量进行赋值，都是为了给new赋值
  new := old
  // Don't try to acquire starving mutex, new arriving goroutines must queue.
  // 新状态只有在非饥饿的条件下才可以加锁
  if old&mutexStarving == 0 {
   new |= mutexLocked
  }
  // 如果old已经处于加锁或者饥饿状态，则等待者按照FIFO的顺序排队
  if old&(mutexLocked|mutexStarving) != 0 {
   new += 1 << mutexWaiterShift
  }

  // 如果符合饥饿条件 且锁还没有被释放，则将其设置为饥饿状态
  // 如果锁已经释放了，那就去抢一次锁。如果进入饥饿模式，那就乖乖去排队了
  if starving && old&mutexLocked != 0 {
   new |= mutexStarving
  }

  // 这里用来消除 awoke 标记
  if awoke {
   if new&mutexWoken == 0 {
    throw("sync: inconsistent mutex state")
   }
   // cas成功
   // 这里用于清除Woken标记，因为后面 goroutine 只会阻塞或者抢锁成功
   // 释放唤醒标识，当前goroutine都不再是唤醒状态了，以便其他goroutine进来

   // cas失败
   // 丢人，所以需要释放之前抢到的 mutexWoken 标识
   new &^= mutexWoken
  }

  // 下面这里尝试给通过CAS操作把old变成new
  // 这里无非就是加锁成功，或者去排队，排队的话需要看排队到头部还是尾部
  if atomic.CompareAndSwapInt32(&m.state, old, new) {

   // 这里还需要看一下
   // 如果原来的old未加锁，且Mutex不处于饥饿状态，那goroutine获取到锁之后就可以直接退出了
   if old&(mutexLocked|mutexStarving) == 0 {
    break // locked the mutex with CAS
   }

   // queueLifo 为true，表示其是被唤醒的，排队时排到头部
   // queueLifo 为false，表示是第一次排队，排队时排到队列尾部
   queueLifo := waitStartTime != 0

   // 第一次排队要记录排队时间
   if waitStartTime == 0 {
    waitStartTime = runtime_nanotime()
   }
   // 这里会阻塞
   runtime_SemacquireMutex(&m.sema, queueLifo, 1)

   // 后续代码是队列里的goroutine被runtime_Semrelease唤醒后，从让出的地方继续执行
   
   // 如果这个协程处于饥饿状态 或 等待时间大于1ms，则设置其为饥饿状态
   starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs

   old = m.state
   // 如果Mutex处于饥饿状态
   if old&mutexStarving != 0 {
    // 这里是一些异常状态
    if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
     throw("sync: inconsistent mutex state")
    }

    // 把Mutex设置为加锁，把等待队列的waiter-1，
    delta := int32(mutexLocked - 1<<mutexWaiterShift)

    // 根据协程的状态看看是否需要切换至正常模式
    if !starving || old>>mutexWaiterShift == 1 {

     delta -= mutexStarving
    }
    atomic.AddInt32(&m.state, delta)
    break
   }

   // goroutine处于正常模式，标记唤醒标识，然后重新自旋去抢锁
   // 执行到这里，这个goroutine是被唤醒的，需要把awoke标记 标识为true
   awoke = true
   iter = 0
  } else {
   // mutex被其他goroutine用了，继续回去自旋吧
   // 赋值失败时还原状态
   old = m.state
  }
 }

 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 != 0 {
  // 说明state其他位不为0, 那就直接进入slow path吧
  m.unlockSlow(new)
 }
}

func (m *Mutex) unlockSlow(new int32) {
 if (new+mutexLocked)&mutexLocked == 0 {
  throw("sync: unlock of unlocked mutex")
 }
 // mutex处于正常模式
 if new&mutexStarving == 0 {
  old := new
  for {
   // 如果等待队列为空 或者 已经有其他goroutine被唤醒 or 获得了锁 or 锁处于饥饿模式
   if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
    // 不需要唤醒goroutine,直接返回即可
    return
   }
   // 抢占Woken标示位，获取唤醒一个goroutine的权利
   new = (old - 1<<mutexWaiterShift) | mutexWoken
   if atomic.CompareAndSwapInt32(&m.state, old, new) {
    // 调用这里唤醒一个goroutine
    runtime_Semrelease(&m.sema, false, 1)
    return
   }
   // 抢占不成功就归位，然后循环去吧
   old = m.state
  }
 } else {
  // 饥饿模式下，后来的goroutine不会争抢锁，
  // 直接唤醒第一个等待者
  runtime_Semrelease(&m.sema, true, 1)
 }
}