golang RWMutex读写锁分析

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 != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
        // 挂起，监控写锁信号量
        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, 1) < 0 {
        // 挂起，监听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, -1); r < 0 {
        if r+1 == 0 || r+1 == -rwmutexMaxReaders {
            race.Enable()
            panic("sync: RUnlock of unlocked RWMutex")
        }
        // 若是获取写锁时的goroutine被阻塞，这时须要获取读锁的goroutine所有都释放，才会被唤醒
        if atomic.AddInt32(&rw.readerWait, -1) == 0 { // 更新须要释放的读锁数量
            // 更新信号量
            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 := 0; i < int(r); i++ {
        runtime_Semrelease(&rw.readerSem)
    }
    // 释放互斥锁资源
    rw.w.Unlock()
    if race.Enabled {
        race.Enable()
    }
}

总结：

读写互斥锁的实现比较有技巧性一些，须要几点

1. 读锁不能阻塞读锁，引入readerCount实现

2. 读锁须要阻塞写锁，直到因此读锁都释放，引入readerSem实现

3. 写锁须要阻塞读锁，直到因此写锁都释放，引入wirterSem实现

4. 写锁须要阻塞写锁，引入Metux实现