go学习笔记 sync/RWMutex源码
RWMutex是一个读写锁,该锁可以加多个读锁或者一个写锁,其经常用于读次数远远多于写次数的场景.
func (rw *RWMutex) Lock() 写锁,如果在添加写锁之前已经有其他的读锁和写锁,则lock就会阻塞直到该锁可用,为确保该锁最终可用,已阻塞的 Lock 调用会从获得的锁中排除新的读取器,即写锁权限高于读锁,有写锁时优先进行写锁定
func (rw *RWMutex) Unlock() 写锁解锁,如果没有进行写锁定,则就会引起一个运行时错误.
func (rw *RWMutex) RLock() 读锁,当有写锁时,无法加载读锁,当只有读锁或者没有锁时,可以加载读锁,读锁可以加载多个,所以适用于"读多写少"的场景
func (rw *RWMutex) RUnlock() 读锁解锁,RUnlock 撤销单次 RLock 调用,它对于其它同时存在的读取器则没有效果。若 rw 并没有为读取而锁定,调用 RUnlock 就会引发一个运行时错误
package sync import ( "internal/race" "sync/atomic" "unsafe" ) // There is a modified copy of this file in runtime/rwmutex.go. // If you make any changes here, see if you should make them there. // A RWMutex is a reader/writer mutual exclusion lock. // The lock can be held by an arbitrary number of readers or a single writer. // The zero value for a RWMutex is an unlocked mutex. // // A RWMutex must not be copied after first use. // // If a goroutine holds a RWMutex for reading and another goroutine might // call Lock, no goroutine should expect to be able to acquire a read lock // until the initial read lock is released. In particular, this prohibits // recursive read locking. This is to ensure that the lock eventually becomes // available; a blocked Lock call excludes new readers from acquiring the // lock. type RWMutex struct { w Mutex // held if there are pending writers // 互斥锁 writerSem uint32 // semaphore for writers to wait for completing readers 写锁信号量 readerSem uint32 // semaphore for readers to wait for completing writers 读锁信号量 readerCount int32 // number of pending readers 读锁计数器 readerWait int32 // number of departing readers 获取写锁时需要等待的读锁释放数量 } const rwmutexMaxReaders = 1 << 30 // 支持最多2^30个读锁 // RLock locks rw for reading. // // It should not be used for recursive read locking; a blocked Lock // call excludes new readers from acquiring the lock. See the // documentation on the RWMutex type. // 它不应该用于递归读锁定; func (rw *RWMutex) RLock() { if race.Enabled { _ = rw.w.state race.Disable() } // 每次goroutine获取读锁时,readerCount+1 // 如果写锁已经被获取,那么readerCount在 - rwmutexMaxReaders与 0 之间,这时挂起获取读锁的goroutine, // 如果写锁没有被获取,那么readerCount>=0,获取读锁,不阻塞 // 通过readerCount的正负判断读锁与写锁互斥,如果有写锁存在就挂起读锁的goroutine,多个读锁可以并行 if atomic.AddInt32(&rw.readerCount, 1) < 0 { // A writer is pending, wait for it. // 将goroutine排到G队列的后面,挂起goroutine, 监听readerSem信号量 runtime_SemacquireMutex(&rw.readerSem, false, 0) } if race.Enabled { race.Enable() race.Acquire(unsafe.Pointer(&rw.readerSem)) } } // RUnlock undoes a single RLock call; // it does not affect other simultaneous readers. // It is a run-time error if rw is not locked for reading // on entry to RUnlock. // 读锁不会影响其他读操作 // 如果在进入RUnlock时没有锁没有被施加读锁的话,则会出现运行时错误。 func (rw *RWMutex) RUnlock() { if race.Enabled { _ = rw.w.state race.ReleaseMerge(unsafe.Pointer(&rw.writerSem)) race.Disable() } // 读锁计数器 -1 // 有四种情况,其中后面三种都会进这个 if // 【一】有读锁,但没有写锁被挂起 // 【二】有读锁,且也有写锁被挂起 // 【三】没有读锁且没有写锁被挂起的时候, r+1 == 0 // 【四】没有读锁但是有写锁被挂起,则 r+1 == -(1 << 30) if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 { // Outlined slow-path to allow the fast-path to be inlined rw.rUnlockSlow(r) } if race.Enabled { race.Enable() } } func (rw *RWMutex) rUnlockSlow(r int32) { // 读锁早就被没有了,那么在此 -1 是需要抛异常的 // 这里只有当读锁没有的时候才会出现的两种极端情况 // 【一】没有读锁且没有写锁被挂起的时候, r+1 == 0 // 【二】没有读锁但是有写锁被挂起,则 r+1 == -(1 << 30) if r+1 == 0 || r+1 == -rwmutexMaxReaders { race.Enable() throw("sync: RUnlock of unlocked RWMutex") } // A writer is pending. // 如果获取写锁时的goroutine被阻塞,这时需要获取读锁的goroutine全部都释放,才会被唤醒 // 更新需要释放的 写锁的等待读锁释放数目 // 最后一个读锁解除时,写锁的阻塞才会被解除. if atomic.AddInt32(&rw.readerWait, -1) == 0 { // The last reader unblocks the writer. // 更新信号量,通知被挂起的写锁去获取锁 runtime_Semrelease(&rw.writerSem, false, 1) } } // Lock locks rw for writing. // If the lock is already locked for reading or writing, // Lock blocks until the lock is available. // 对一个已经lock的rw上锁会被阻塞 // 如果锁已经锁定以进行读取或写入,则锁定将被阻塞,直到锁定可用。 func (rw *RWMutex) Lock() { if race.Enabled { _ = rw.w.state race.Disable() } // First, resolve competition with other writers. // 首先,获取互斥锁,与其他来获取写锁的goroutine 互斥 rw.w.Lock() // Announce to readers there is a pending writer. // 告诉其他来获取读锁操作的goroutine,现在有人获取了写锁 // 减去最大的读锁数量,用0 -负数 来表示写锁已经被获取 r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders // Wait for active readers. // 设置需要等待释放的读锁数量,如果有,则挂起获取 竞争写锁 goroutine if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 { // 挂起,监控写锁信号量 runtime_SemacquireMutex(&rw.writerSem, false, 0) } if race.Enabled { race.Enable() race.Acquire(unsafe.Pointer(&rw.readerSem)) race.Acquire(unsafe.Pointer(&rw.writerSem)) } } // Unlock unlocks rw for writing. It is a run-time error if rw is // not locked for writing on entry to Unlock. // // As with Mutexes, a locked RWMutex is not associated with a particular // goroutine. One goroutine may RLock (Lock) a RWMutex and then // arrange for another goroutine to RUnlock (Unlock) it. // 如果在写锁时,rw没有被解锁,则会出现运行时错误。 // 与互斥锁一样,锁定的RWMutex与特定的goroutine无关。 // 一个goroutine可以RLock(锁定)RWMutex然后安排另一个goroutine到RUnlock(解锁)它。 func (rw *RWMutex) Unlock() { if race.Enabled { _ = rw.w.state race.Release(unsafe.Pointer(&rw.readerSem)) race.Disable() } // Announce to readers there is no active writer. // 向读锁的goroutine发出通知,现在已经没有写锁了 // 还原加锁时减去的那一部分readerCount r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders) if r >= rwmutexMaxReaders { // 读锁数目超过了 最大允许数 race.Enable() throw("sync: Unlock of unlocked RWMutex") } // Unblock blocked readers, if any. // 唤醒获取读锁期间所有被阻塞的goroutine for i := 0; i < int(r); i++ { runtime_Semrelease(&rw.readerSem, false, 0) } // Allow other writers to proceed. rw.w.Unlock() // 释放互斥锁资源 if race.Enabled { race.Enable() } } // RLocker returns a Locker interface that implements // the Lock and Unlock methods by calling rw.RLock and rw.RUnlock. // RLocker返回一个Locker接口的实现 // 通过调用rw.RLock和rw.RUnlock来锁定和解锁方法。 func (rw *RWMutex) RLocker() Locker { return (*rlocker)(rw) } type rlocker RWMutex func (r *rlocker) Lock() { (*RWMutex)(r).RLock() } func (r *rlocker) Unlock() { (*RWMutex)(r).RUnlock() }
从上面的代码中我们可以看到,读写锁首先是内置了一个互斥锁,然后再加上维护各种计数器来实现的读写锁,紧接着提供了四个函数支撑着读写锁操作,由 Lock 和Unlock 分别支持写锁的锁定和释放,由RLock 和RUnlock 来支持读锁的的锁定和释放。其中,读锁不涉及 内置mutex的使用,写锁用了mutex来排斥其他写锁。
读写互斥锁的实现比较有技巧性一些,需要几点
1. 读锁不能阻塞读锁,引入readerCount实现
2. 读锁需要阻塞写锁,直到所以读锁都释放,引入readerSem实现
3. 写锁需要阻塞读锁,直到所以写锁都释放,引入wirterSem实现
4. 写锁需要阻塞写锁,引入Metux实现
【读锁的】Rlock:
【读锁的】RUnlock:
【写锁的】Lock:
【写锁的】Unlock:
参考 https://blog.csdn.net/qq_25870633/article/details/83448234