package main

import "sync"

func main() {
 m := sync.Mutex{}
 m.Lock()
 defer m.Unlock()
  // do something
}

type Mutex struct {
 state int32 // 锁竞争的状态值
 sema  uint32 // 信号量
}

func (m *Mutex) Lock() {
 // Fast path: grab unlocked mutex.
 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)
 m.lockSlow()
}

package main

import "sync"

func main() {
 m := sync.Mutex{}
 m.Lock()
  //这里会导致死锁
 m.Lock()
 defer m.Unlock()
}

func (m *Mutex) lockSlow() {
 var waitStartTime int64
 starving := false
 awoke := false
 iter := 0
 old := m.state
 for {
    //饥饿模式下不能自旋,也没有资格抢占，锁是手递手给到等待的goroutine
  if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {//当Mutex处于正常模式且能够自旋
      //设置mutexWoken为1 告诉unlock操作，存在自旋gorountine 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
    //当mutex处于正常模式，将new的mutexLocked设置为1 即准备抢占锁
  if old&mutexStarving == 0 {
   new |= mutexLocked
  }
    //加锁状态或饥饿模式下 新来的goroutine进入等待队列
  if old&(mutexLocked|mutexStarving) != 0 {
   new += 1 << mutexWaiterShift
  }

    //将Mutex切换为饥饿模式，若未加锁则不必切换
    //Unlock操作希望饥饿模式存在等待者
  if starving && old&mutexLocked != 0 {
   new |= mutexStarving
  }
  if awoke {
      // 当前goroutine自旋过 已被被唤醒，则需要将mutexWoken重置
   if new&mutexWoken == 0 {
    throw("sync: inconsistent mutex state")
   }
   new &^= mutexWoken //重置mutexWoken
  }
  if atomic.CompareAndSwapInt32(&m.state, old, new) {
      // 当前goroutine获取锁前mutex处于未加锁 正常模式下
   if old&(mutexLocked|mutexStarving) == 0 {
    break // 使用CAS成功抢占到锁
   }
   // waitStartTime!=0表示当前goroutine是等待状态唤醒的 
      // 为了与第一次调用Lock的goroutine划分不同的优先级
   queueLifo := waitStartTime != 0
   if waitStartTime == 0 {
        //开始记录等待时间
    waitStartTime = runtime_nanotime()
   }
      // 将被唤醒但是没有获得锁的goroutine插入到当前等待队列队首
      // 使用信号量阻塞当前goroutine
   runtime_SemacquireMutex(&m.sema, queueLifo, 1)
      // 当goroutine等待时间超过starvationThresholdNs，mutex进入饥饿模式
   starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs
   old = m.state
   if old&mutexStarving != 0 {
        //如果当前goroutine被唤醒且mutex处于饥饿模式 则将锁手递手交给当前goroutine
    if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
     throw("sync: inconsistent mutex state")
    }
        //等待状态的goroutine - 1
    delta := int32(mutexLocked - 1<<mutexWaiterShift)
        //如果等待时间小于1ms 或 当前goroutine是队列中最后一个
    if !starving || old>>mutexWaiterShift == 1 {
      // 退出饥饿模式
     delta -= mutexStarving
    }
    atomic.AddInt32(&m.state, delta)
    break
   }
   awoke = true
   iter = 0
  } else {
   old = m.state
  }
 }
}

func (m *Mutex) Unlock() {

 // 去除加锁状态
 new := atomic.AddInt32(&m.state, -mutexLocked)
 if new != 0 {//存在等待的goroutine
  m.unlockSlow(new)
 }
}

func (m *Mutex) unlockSlow(new int32) {
  //未加锁的情况下不能多次调用unlock
 if (new+mutexLocked)&mutexLocked == 0 {
  throw("sync: unlock of unlocked mutex")
 }
 if new&mutexStarving == 0 {//正常模式下
  old := new
  for {
      //没有等待的goroutine 或 已经存在一个获得锁 或被唤醒 或处于饥饿模式下不需要唤醒任何处于等待的goroutine
   if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
    return
   }
   // 等待状态goroutine数量-1 并设置唤醒状态为1 然后唤醒一个等待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
    //即使期间有新来的goroutine到来，只要处于饥饿模式 锁就不会被新来的goroutine抢占
  runtime_Semrelease(&m.sema, true, 1)
 }
}

// Prime to not correlate with any user patterns.
const semTabSize = 251

var semtable [semTabSize]struct {
 root semaRoot
 pad  [cpu.CacheLinePadSize - unsafe.Sizeof(semaRoot{})]byte
}

type semaRoot struct {
 lock  mutex
 treap *sudog // root of balanced tree of unique waiters.
 nwait uint32 // Number of waiters. Read w/o the lock.
}

//go:linkname sync_runtime_SemacquireMutex sync.runtime_SemacquireMutex
func sync_runtime_SemacquireMutex(addr *uint32, lifo bool, skipframes int) {
 semacquire1(addr, lifo, semaBlockProfile|semaMutexProfile, skipframes)
}

func semacquire1(addr *uint32, lifo bool, profile semaProfileFlags, skipframes int) {
 gp := getg()
 if gp != gp.m.curg {
  throw("semacquire not on the G stack")
 }

 // 低成本case
  // 若addr大于1 并通过CAS -1 成功，则获取信号量成功 不需要阻塞
 if cansemacquire(addr) {
  return
 }

 // 复杂 case:
 // 增加等待goroutine数量
 // 再次尝试cansemacquire 成功则返回
 // 失败则将自己作为一个waiter入队
 // sleep
 // (waiter descriptor is dequeued by signaler)
 s := acquireSudog()
 root := semroot(addr)
 t0 := int64(0)
 s.releasetime = 0
 s.acquiretime = 0
 s.ticket = 0
 if profile&semaBlockProfile != 0 && blockprofilerate > 0 {
  t0 = cputicks()
  s.releasetime = -1
 }
 if profile&semaMutexProfile != 0 && mutexprofilerate > 0 {
  if t0 == 0 {
   t0 = cputicks()
  }
  s.acquiretime = t0
 }
 for {
  lock(&root.lock)
  // 给nwait+1 这样semrelease中不会进低成本路径了
  atomic.Xadd(&root.nwait, 1)
  // 检查 cansemacquire 避免错过唤醒
  if cansemacquire(addr) {
   atomic.Xadd(&root.nwait, -1)
   unlock(&root.lock)
   break
  }
    //cansemacquire之后的semrelease都可以知道我们正在等待
    //上面设置了nwait，所以会直接进入sleep 即goparkunlock
  root.queue(addr, s, lifo)
  goparkunlock(&root.lock, waitReasonSemacquire, traceEvGoBlockSync, 4+skipframes)
  if s.ticket != 0 || cansemacquire(addr) {
   break
  }
 }
 if s.releasetime > 0 {
  blockevent(s.releasetime-t0, 3+skipframes)
 }
 releaseSudog(s)
}

//go:linkname sync_runtime_Semrelease sync.runtime_Semrelease
func sync_runtime_Semrelease(addr *uint32, handoff bool, skipframes int) {
 semrelease1(addr, handoff, skipframes)
}

func semrelease1(addr *uint32, handoff bool, skipframes int) {
 root := semroot(addr)
 atomic.Xadd(addr, 1)

 // Easy case: no waiters?
 // 这个检查必须发生在xadd之后 避免错过唤醒
 // (see loop in semacquire).
 if atomic.Load(&root.nwait) == 0 {
  return
 }

 // Harder case: 搜索一个waiter 并唤醒它
 lock(&root.lock)
 if atomic.Load(&root.nwait) == 0 {
  // count值已经被另一个goroutine消费了
  // 所以不需要唤醒其他goroutine
  unlock(&root.lock)
  return
 }
 s, t0 := root.dequeue(addr)
 if s != nil {
  atomic.Xadd(&root.nwait, -1)
 }
 unlock(&root.lock)
 if s != nil { // May be slow, so unlock first
  acquiretime := s.acquiretime
  if acquiretime != 0 {
   mutexevent(t0-acquiretime, 3+skipframes)
  }
  if s.ticket != 0 {
   throw("corrupted semaphore ticket")
  }
  if handoff && cansemacquire(addr) {
   s.ticket = 1
  }
  readyWithTime(s, 5+skipframes)
 }
}