源码文件：src/sync/mutex.go    line：34

type Mutex struct {
    state int32
    sema  uint32
}

源码文件：src/sync/mutex.go    line：81

func (m *Mutex) Lock() {
    // Fast path: 当Mutex处于Unlocked状态，没有goroutine在排队，更没有饥饿，即Mutex.state = 0 时，可以直接获得锁
    if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
                ...　　//精简了race检测相关的代码
                return
    }
    // 当没有直接获得锁时，进入 Slow path
    m.lockSlow()
}

源码文件：src/sync/mutex.go    line：45、117

const(
　　mutexLocked = 1 << iota　　//0000 0001B
　　mutexWoken　　//0000 0010B
　　mutexStarving　　//0000 0100B
　　mutexWaiterShift = iota　　// = 3
　　starvationThresholdNs = 1e6
)
...
func (m *Mutex) lockSlow() {
    var waitStartTime int64 // 当前goroutine等待时间
    starving := false // 当前goroutine是否处于饥饿状态
    awoke := false // 当前goroutine是否处于唤醒状态
    iter := 0 // 当前goroutine自旋迭代次数
    old := m.state　　//复制当前锁状态
    for {
        if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {　　//判断 old 不处于饥饿状态，且已加锁，当前goroutine自旋次数小于4次

            if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&　　//当前goroutine不处于唤醒状态，且锁的 waiter != 0时
                atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {　　//将 m.state 设置为唤醒，通知Unlock不要唤醒其他goroutines
                awoke = true
            }
            runtime_doSpin()　　//自旋等待锁的释放
            iter++
            old = m.state　　//新状态覆盖老状态
            continue
        }
    　　 ...

（紧接上述代码）
　　　 //new 用来设置新的状态
      new := old //如果来到这里就停止自旋了，如果第一次来到这里，说明只执行了自旋，并且有进行其他操作，也没为饥饿

       //如果 old 不是饥饿状态，尝试获得锁
      if old&mutexStarving == 0 {　　//old&mutexStarving == 0 相当于(old & 0000 0100B) == 0,说明原来不是饥饿模式
         new |= mutexLocked  //意思是将m.state的最后一位置为1 ,new 现在是上锁了
      }

　　　　//如果 old 处于加锁或饥饿状态，goroutine 进入等待队列
      if old&(mutexLocked|mutexStarving) != 0 {    //mutexLocked|mutexStarving == 0000 0001B|0000 0100B = 0000 0101B
         //(old & 0000 0101B)！=0说明，原来是加锁的或者原来是饥饿的
         new += 1 << mutexWaiterShift //此时将waiter数量+1
      }

　　　　//如果当前 goroutine 处于饥饿状态，且 old 处于加锁状态，将 new 设为饥饿状态
      if starving && old&mutexLocked != 0 { 
         new |= mutexStarving
      }

　　　　//如果当前 goroutine 是被唤醒状态，重置 锁（new）的唤醒标志
　　　　//因为接下来 goroutine 要么是拿到锁了，要么是进入了等待队列
      if awoke {
         if new&mutexWoken == 0 {
            throw("sync: inconsistent mutex state")
         }
         // &^ 是将new 的唤醒位清空
         // mutexWoken=&0000 0010B，当任何数与这个进行&^操作时，都会被置为0,如果new Woken为1，那么就会被清空为0，如果new Woken为0,那么与左侧保持一致，为0。
         new &^= mutexWoken
      }  

（紧接上述代码）

//尝试将 m.state 设置为 new
if atomic.CompareAndSwapInt32(&m.state, old, new) {
    // 进入这个代码块代表锁状态被改变了，不一定是上锁成功
    if old&(mutexLocked|mutexStarving) == 0 {
        // 成功上锁
        break // locked the mutex with CAS
    }
    
    queueLifo := waitStartTime != 0    // 如果 waitStartTime = 0，则queueLifo = false，说明之前已经等待过了，放到等待队列头，否则排队列尾
    if waitStartTime == 0 {
        waitStartTime = runtime_nanotime()    // 如果没有等待过，就初始化设置现在的等待时间
    }

    runtime_SemacquireMutex(&m.sema, queueLifo, 1)    // 使用 sleep 原语来阻塞当前 goroutine，直到被唤醒
    
    // 被唤醒后，从此处开始执行

    starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs  // 如果当前 goroutine 等待时间超过 starvationThresholdNs，mutex 进入饥饿模式    
    old = m.state    // 再次获取锁当前状态
    if old&mutexStarving != 0 {    //old 处于饥饿状态，且当前 goroutine 被唤醒，意味锁被直接交给了当前 goroutine
        if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {    //old 处于非法状态时
            throw("sync: inconsistent mutex state")
        }
        delta := int32(mutexLocked - 1<<mutexWaiterShift)    // 当前的goroutine获得了锁，那么就把等待队列-1

        if !starving || old>>mutexWaiterShift == 1 {    // 如果当前 goroutine 不是饥饿模式或只剩一个等待者时
            delta -= mutexStarving    // 锁退出饥饿模式
        }
        atomic.AddInt32(&m.state, delta)    // 设置新state, 因为已经获得了锁，退出、返回
        break
    }
    // 如果锁不是饥饿模式，就把当前的goroutine设为被唤醒，并且重置iter(重置spin)
    awoke = true
    iter = 0
} else {
    // 如果CAS不成功，重新获取锁的state, 从for循环开始处重新开始
    old = m.state
} 

源码文件：src/sync/mutex.go    line：212

func (m *Mutex) Unlock() {
        ...    //精简了race检测相关的代码

    // Fast path: 原子操作释放锁
    new := atomic.AddInt32(&m.state, -mutexLocked)
    if new != 0 {
        //  根据 state 的新值 new 来判断是否需要执行 Slow path
        m.unlockSlow(new)
    }
}

源码文件：src/sync/mutex.go    line：227

func (m *Mutex) unlockSlow(new int32) {
    if (new+mutexLocked)&mutexLocked == 0 {    //new+mutexLocked代表将锁置为1，如果两个状态& 不为0，则说明重复解锁，panic
        fatal("sync: unlock of unlocked mutex")
    }
    if new&mutexStarving == 0 {    //锁不处于饥饿状态
        old := new
        for {
            //当等待队列为 0 或锁处于 加锁、唤醒或饥饿状态时
            if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
                return    //直接返回，因为在唤醒状态时，goroutine 会自己抢锁，饥饿状态会直接把锁给队头
            }
            //等待队列-1，并让锁进入唤醒状态
            new = (old - 1<<mutexWaiterShift) | mutexWoken
            if atomic.CompareAndSwapInt32(&m.state, old, new) {    //更新锁状态，尝试获取唤醒一个 goroutine 的权力
                runtime_Semrelease(&m.sema, false, 1)　　//更新成功，唤醒一个 goroutine
                return
            }
            old = m.state　　//更新失败，获取当前锁状态，循环尝试
        }
    } else {
        //锁处于饥饿模式，把锁直接交给等待队列头
        runtime_Semrelease(&m.sema, true, 1)
    }
}

源码文件：src/sync/rwmutex.go    line：35

type RWMutex struct {
    w           Mutex  // 复用互斥锁
    writerSem   uint32 // 信号量，用于写等待读
    readerSem   uint32 // 信号量，用于读等待写
    readerCount int32  // 当前执行读的 goroutine 数量
    readerWait  int32  // 写操作被阻塞的准备读的 goroutine 的数量
}