RWMutex：是基于Mutex实现的读写互斥锁，一个goroutine可以持有多个读锁或者一个写锁，同一时刻只能持有读锁或者写锁
数据结构设计：
type RWMutex struct {
w Mutex // 互斥锁
writerSem uint32 // 写锁信号量
readerSem uint32 // 读锁信号量
readerCount int32 // 读锁计数器
readerWait int32 // 获取写锁时需要等待的读锁释放数量
}
// 获取写锁
func (rw *RWMutex) Lock() {
if race.Enabled {
_ = rw.w.state
race.Disable()
}
// 先获取一把互斥锁
rw.w.Lock()
// 减去最大的读锁数量，用0-负数来表示写锁已经被获取
r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
// 设置需要等待释放的读锁数量，如果有，则挂起获取读锁的goroutine
if r != && atomic.AddInt32(&rw.readerWait, r) != {
// 挂起，监控写锁信号量
runtime_Semacquire(&rw.writerSem)
}
if race.Enabled {
race.Enable()
race.Acquire(unsafe.Pointer(&rw.readerSem))
race.Acquire(unsafe.Pointer(&rw.writerSem))
}
}
按顺序这里应该介绍释放写锁的代码了，但是由于获取写锁中有很重要的几个逻辑变量，跟获取读锁时强依赖，所以在这里先说说获取读锁的逻辑
// 获取读锁
func (rw *RWMutex) RLock() {
if race.Enabled {
_ = rw.w.state
race.Disable()
} // 每次获取读锁时，readerCount+1
// 如果写锁已经被获取，那么readerCount在-rwmutexMaxReaders与0之间，这时挂起获取读锁的goroutine，
// 如果写锁没有被获取，那么readerCount>=0，然后就没然后了
// 这样通过readerCount的正负就成了读锁与写锁互斥的判断条件 if atomic.AddInt32(&rw.readerCount, ) < {
// 挂起，监听readerSem信号量
runtime_Semacquire(&rw.readerSem)
}
if race.Enabled {
race.Enable()
race.Acquire(unsafe.Pointer(&rw.readerSem))
}
}
// 释放读锁
func (rw *RWMutex) RUnlock() {
if race.Enabled {
_ = rw.w.state
race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
race.Disable()
}
// 读锁计数器-1
if r := atomic.AddInt32(&rw.readerCount, -); r < {
if r+ == || r+ == -rwmutexMaxReaders {
race.Enable()
panic("sync: RUnlock of unlocked RWMutex")
}
// 如果获取写锁时的goroutine被阻塞，这时需要获取读锁的goroutine全部都释放，才会被唤醒
if atomic.AddInt32(&rw.readerWait, -) == { // 更新需要释放的读锁数量
// 更新信号量
runtime_Semrelease(&rw.writerSem)
}
}
if race.Enabled {
race.Enable()
}
}
func (rw *RWMutex) Unlock() {
if race.Enabled {
_ = rw.w.state
race.Release(unsafe.Pointer(&rw.readerSem))
race.Release(unsafe.Pointer(&rw.writerSem))
race.Disable()
}
// 还原加锁时减去的那一部分readerCount
r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
if r >= rwmutexMaxReaders {
race.Enable()
panic("sync: Unlock of unlocked RWMutex")
}
// 唤醒获取读锁期间所有被阻塞的goroutine
for i := ; i < int(r); i++ {
runtime_Semrelease(&rw.readerSem)
}
// 释放互斥锁资源
rw.w.Unlock()
if race.Enabled {
race.Enable()
}
}
总结：
读写互斥锁的实现比较有技巧性一些，需要几点
1. 读锁不能阻塞读锁，引入readerCount实现
2. 读锁需要阻塞写锁，直到所以读锁都释放，引入readerSem实现
3. 写锁需要阻塞读锁，直到所以写锁都释放，引入wirterSem实现
4. 写锁需要阻塞写锁，引入Metux实现