Go中锁的那些姿势，估计你不知道

https://github.com/sunpengwei1992/java_common/tree/master/src/lock

type Locker interface {
   Lock()
   Unlock()
}
type Mutex struct {
   state int32 //初始值默认为0
   sema  uint32 //初始值默认为0
}

var lock sync.Mutex

func MutexStudy(){
    //获取锁
    lock.Lock()
    //业务逻辑操作
    time.Sleep(1 * time.Second)
    //释放锁
    defer lock.Unlock()
}

const (
   mutexLocked = 1 << iota //1, 0001 最后一位表示当前锁的状态，0未锁，1已锁
   mutexWoken //2, 0010，倒数第二位表示当前锁是否会被唤醒,0唤醒，1未唤醒
   mutexStarving //4, 0100 倒数第三位表示当前对象是否为饥饿模式,0正常，1饥饿
   mutexWaiterShift = iota //3 从倒数第四位往前的bit表示排队的gorouting数量
   starvationThresholdNs = 1e6 // 饥饿的阈值：1ms
）
//Mutex中的变量，这里主要是将常量映射到state上面
state //0代表未获取到锁，1代表得到锁，2-2^31表示gorouting排队的数量的
sema //非负数的信号量，阻塞协程的依据

//对state进行cas修改操作，修改成功相当于获取锁，修改之后state=1
if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
    return
}

//开始等待时间
var waitStartTime int64
//这几个变量含义依次是：是否饥饿，是否唤醒，自旋次数，锁的当前状态
starving := false；awoke := false；iter := 0；old := m.state
//进入死循环，直到获得锁成功(获得锁成功就是有别的协程释放锁了）
for {
    //这个if的核心逻辑是判断：已经获得锁了并且不是饥饿模式 && 可以自旋，与cpu核数有关
    if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) {
           //这个是判断：没有被唤醒 && 有排队等待的协程 && 尝试设置通知被唤醒
        if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 && atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
           //说明上个协程此时已经unlock了，唤醒当前协程
            awoke = true
        }
        //自旋一段时间
        runtime_doSpin()
        //自选次数加1
        iter++
        old = m.state
        continue
    }
}

new := old
 //1：原协程已经unlock了，对new的修改为已锁
if old&mutexStarving == 0 { 
    new |= mutexLocked
}
//2：这里是执行完自旋或者没执行自旋（原协程没有unlock）
if old&(mutexLocked|mutexStarving) != 0 {
    new += 1 << mutexWaiterShift //排队
}
//3：如果是饥饿模式，并且已锁的状态
if starving && old&mutexLocked != 0 {
    new |= mutexStarving //设置new为饥饿状态
}
 //4：上面的awoke被设置为true
if awoke {
    //当前协程被唤醒了，肯定不为0
    if new&mutexWoken == 0 {
        throw("sync: inconsistent mutex state")
    }
    //既然当前协程被唤醒了，重置唤醒标志为0
    new &^= mutexWoken
}
//修改state的值为new，但这里new的值会有四种情况，
//就是上面4个if情况对new做的修改，这一步获取锁成功
if atomic.CompareAndSwapInt32(&m.state, old, new) {
    if old&(mutexLocked|mutexStarving) == 0 {
        //这里代表的是正常模式获取锁成功
        break 
    }
    //下面的代码是判断是否从饥饿模式恢复正常模式
    queueLifo := waitStartTime != 0
    if waitStartTime == 0 {
        waitStartTime = runtime_nanotime()
    }
   //进入阻塞状态
    runtime_SemacquireMutex(&m.sema, queueLifo)
   //设置是否为饥饿模式，等待的时间大于1ms就是饥饿模式
    starving=starving||runtime_nanotime()-waitStartTime> starvationThresholdNs
    old = m.state
    //如果当前锁是饥饿模式，但这个gorouting被唤醒
    if old&mutexStarving != 0 {
        if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 {
                    throw("sync: inconsistent mutex state")
        }
       //减去当前锁的排队
        delta := int32(mutexLocked - 1<<mutexWaiterShift)
        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+mutexLocked)&mutexLocked == 0 {
      throw("sync: unlock of unlocked mutex")
   }
   //判断当前锁是否饥饿模式,==0代表不是
   if new&mutexStarving == 0 {
      old := new
      for {
         //如果没有未排队的协程 或者 有已经被唤醒，得到锁或饥饿的协程，则直接返回
         if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 {
            return
         }
         //唤醒其它协程
         new = (old - 1<<mutexWaiterShift) | mutexWoken
         if atomic.CompareAndSwapInt32(&m.state, old, new) {
            runtime_Semrelease(&m.sema, false)
            return
         }
         old = m.state
      }
   } else {
      //释放信号量
      runtime_Semrelease(&m.sema, true)
   }
}