详解Golang互斥锁内部实现

go语言提供了一种开箱即用的共享资源的方式，互斥锁(sync.Mutex), sync.Mutex的零值表示一个没有被锁的，可以直接使用的，一个goroutine获得互斥锁后其他的goroutine只能等到这个gorutine释放该互斥锁,在Mutex结构中只公开了两个函数，分别是Lock和Unlock，在使用互斥锁的时候非常简单，本文并不阐述使用。

成都创新互联公司服务项目包括乌苏网站建设、乌苏网站制作、乌苏网页制作以及乌苏网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，乌苏网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到乌苏省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！

在使用sync.Mutex的时候千万不要做值拷贝，因为这样可能会导致锁失效。当我们打开我们的IDE时候跳到我们的sync.Mutex 代码中会发现它有如下的结构:

type Mutex struct {
 state int32   //互斥锁上锁状态枚举值如下所示
 sema uint32  //信号量，向处于Gwaitting的G发送信号
}

const (
 mutexLocked = 1 << iota // 1 互斥锁是锁定的
 mutexWoken       // 2 唤醒锁
 mutexWaiterShift = iota // 2 统计阻塞在这个互斥锁上的goroutine数目需要移位的数值
)

上面的state值分别为 0(可用) 1(被锁) 2~31等待队列计数

下面是互斥锁的源码，这里会有四个比较重要的方法需要提前解释，分别是runtime_canSpin，runtime_doSpin，runtime_SemacquireMutex，runtime_Semrelease，

1、runtime_canSpin：比较保守的自旋，golang中自旋锁并不会一直自旋下去，在runtime包中runtime_canSpin方法做了一些限制, 传递过来的iter大等于4或者cpu核数小等于1，最大逻辑处理器大于1，至少有个本地的P队列，并且本地的P队列可运行G队列为空。

//go:linkname sync_runtime_canSpin sync.runtime_canSpin
func sync_runtime_canSpin(i int) bool {
 if i >= active_spin || ncpu <= 1 || gomaxprocs <= int32(sched.npidle+sched.nmspinning)+1 {
 return false
 }
 if p := getg().m.p.ptr(); !runqempty(p) {
 return false
 }
 return true
}

2、 runtime_doSpin：会调用procyield函数，该函数也是汇编语言实现。函数内部循环调用PAUSE指令。PAUSE指令什么都不做，但是会消耗CPU时间，在执行PAUSE指令时，CPU不会对它做不必要的优化。

//go:linkname sync_runtime_doSpin sync.runtime_doSpin
func sync_runtime_doSpin() {
 procyield(active_spin_cnt)
}

3、runtime_SemacquireMutex:

//go:linkname sync_runtime_SemacquireMutex sync.runtime_SemacquireMutex
func sync_runtime_SemacquireMutex(addr *uint32) {
 semacquire(addr, semaBlockProfile|semaMutexProfile)
}

4、runtime_Semrelease:

//go:linkname sync_runtime_Semrelease sync.runtime_Semrelease
func sync_runtime_Semrelease(addr *uint32) {
 semrelease(addr)
}
Mutex的Lock函数定义如下

func (m *Mutex) Lock() {
    //先使用CAS尝试获取锁
 if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
        //这里是-race不需要管它
 if race.Enabled {
  race.Acquire(unsafe.Pointer(m))
 }
        //成功获取返回
 return
 }

 awoke := false //循环标记
 iter := 0    //循环计数器
 for {
 old := m.state //获取当前锁状态
 new := old | mutexLocked //将当前状态最后一位指定1
 if old&mutexLocked != 0 { //如果所以被占用
  if runtime_canSpin(iter) { //检查是否可以进入自旋锁
  if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
   atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) { 
                    //awoke标记为true
   awoke = true
  }
                //进入自旋状态
  runtime_doSpin()
  iter++
  continue
  }
            //没有获取到锁，当前G进入Gwaitting状态
  new = old + 1<>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {
  return
 }
 // 减少等待次数，添加清除标记
 new = (old - 1<

互斥锁无冲突是最简单的情况了，有冲突时，首先进行自旋，，因为大多数的Mutex保护的代码段都很短，经过短暂的自旋就可以获得；如果自旋等待无果，就只好通过信号量来让当前Goroutine进入Gwaitting状态。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持创新互联。

网页标题：详解Golang互斥锁内部实现
地址分享：http://ybzwz.com/article/iicshp.html

详解Golang互斥锁内部实现

其他资讯