golang Mutex 实现上的几个巧妙的点

开发十年，就只剩下这套Java开发体系了 >>>   

    golang 的metux 的实现有几个点做法是非常有意思的，一个是底层数据结构上，用了平时很少用的位运算，第二个，用到了自旋，并做了自旋策略控制，最后是用了信号量控制协程。

    首先是golang mutex 中用了很多位运算。位运算不做细介绍，对内存利用比较高的算法都有涉及，比如redies 的压缩列表，比如golang 的Protobuffer。

    有几个关键点，iota 在定义的时候，用的多，做自增运算：    

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

// 这里 第一个变量为1 ，第二个变量为10， 第三个为10 

    然后，位运算的求或和求与用的很多，一个是与1 求或将某位置1，一个是与0 求与将某位置0，这些都是用于改变某些标志位的方式，不要看懵逼了：

        new := old | mutexLocked // 将old 的最后一位置1，表示new 锁一定是被持有状态
        if old&mutexLocked != 0 { // 将最后一位保留后，其他位全部置0， 判断最后一位的状态是不是0，判断是不是被持有
            if runtime_canSpin(iter) {
                // Active spinning makes sense.
                // Try to set mutexWoken flag to inform Unlock
                // to not wake other blocked goroutines.
                if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
                    atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) {
                    awoke = true
                }
                runtime_doSpin()
                iter++
                continue
            }
            new = old + 1<<mutexWaiterShift
        }

    第二个是golang 的加锁会自旋，4次自旋没拿到锁后再将协程休眠，这样可以减少切换成本。这里关判断条件是自旋次数，cpu核数，p 的数量：

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
}

    最后是利用信号量挂起和唤醒协程，核心函数是

runtime_SemacquireMutex(&m.sema)
runtime_Semrelease(&m.sema)

    获取信号时，当s > 0 ,将s--,如果s 为负数，会将当前g 放入阻塞队列，挂起直到s>0。

func (m *Mutex) Lock() {
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		if race.Enabled {
			race.Acquire(unsafe.Pointer(m))
		}
		return // cas 获取到锁，直接返回
	}

	awoke := false  //循环标记
	iter := 0       //循环计数器
	for {
		old := m.state            //保存当前锁状态
		new := old | mutexLocked  //将状态位最后一位指定1
		if old&mutexLocked != 0 { //锁被占用
			if runtime_canSpin(iter) { //检查是否可以进入自旋锁，4次
				if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 &&
					atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) { 
                                        //awoke标记为true
					awoke = true
				}
                                
				runtime_doSpin()//进入自旋
				iter++
				continue
			}
                       
			new = old + 1<<mutexWaiterShift //锁被占用，且自旋次数超过4次，挂起协程数+1，下面步骤将g 挂起并等待
		}
		if awoke {
			if new&mutexWoken == 0 {
				throw("sync: inconsistent mutex state")
			}
			new &^= mutexWoken //清除标志
		}
               
		if atomic.CompareAndSwapInt32(&m.state, old, new) { //更新协程计数
			if old&mutexLocked == 0 {
				break
			}
                         
                        // 锁请求失败,进入休眠状态,等待信号唤醒后重新开始循环，一直阻塞在这里
			runtime_SemacquireMutex(&m.sema)
			awoke = true
			iter = 0
		}
	}

	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+mutexLocked)&mutexLocked == 0 {
		throw("sync: unlock of unlocked mutex")
	}

	old := new
	for {
		//当休眠队列内的等待计数为0或者自旋状态计数器为0，退出
		if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken) != 0 {
			return
		}
		// 等待协程数-1，更改清除标记位
		new = (old - 1<<mutexWaiterShift) | mutexWoken
		if atomic.CompareAndSwapInt32(&m.state, old, new) {         
			runtime_Semrelease(&m.sema)// 释放锁,发送释放信号,对应之前的acquire
			return
		}
		old = m.state
	}
}