008-Golang1.17源码分析之rwmutex

Golang1.17源码分析之rwmutex-008

Golang1.17 学习笔记008

解决的问题：

写锁需要阻塞写锁：一个协程拥有写锁时，其他协程写锁定需要阻塞

写锁需要阻塞读锁：一个协程拥有写锁时，其他协程读锁定需要阻塞

读锁需要阻塞写锁：一个协程拥有读锁时，其他协程写锁定需要阻塞

读锁不能阻塞读锁：一个协程拥有读锁时，其他协程也可以拥有读锁

源代码：src/sync/rwmutex.go

数据结构：

type RWMutex struct {
    w           Mutex  //用于控制多个写锁，获得写锁首先要获取该锁，如果有一个写锁在进行，那么再到来的写锁将会阻塞于此
    writerSem   uint32 //写阻塞等待的信号量，最后一个读者释放锁时会释放信号量
    readerSem   uint32 //读阻塞的协程等待的信号量，持有写锁的协程释放锁后会释放信号量
    readerCount int32  //记录读者个数
    readerWait  int32  //记录写阻塞时读者个数，这也是写锁不会被饿死的核心
}

加读锁：readerCount++ -> 等待写操作结束

func (rw *RWMutex) RLock() {
	if atomic.AddInt32(&rw.readerCount, 1) < 0 {
		// A writer is pending, wait for it.
		runtime_SemacquireMutex(&rw.readerSem, false, 0)
	}
}

解读锁：readerCount-- -> 如果有写锁或者是最后一个读，那么唤醒被阻塞的写操作

func (rw *RWMutex) RUnlock() {
	if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
		// Outlined slow-path to allow the fast-path to be inlined
		rw.rUnlockSlow(r)
	}
}

func (rw *RWMutex) rUnlockSlow(r int32) {
	if r+1 == 0 || r+1 == -rwmutexMaxReaders {
		race.Enable()
		throw("sync: RUnlock of unlocked RWMutex")
	}
	// A writer is pending.
	if atomic.AddInt32(&rw.readerWait, -1) == 0 {
		// The last reader unblocks the writer.
		runtime_Semrelease(&rw.writerSem, false, 1)
	}
}

加写锁：获取互斥锁 -> 等待读结束

func (rw *RWMutex) Lock() {
	// First, resolve competition with other writers.
	rw.w.Lock()
	// Announce to readers there is a pending writer.
	r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
	// Wait for active readers.
	if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
		runtime_SemacquireMutex(&rw.writerSem, false, 0)
	}
}

解写锁：唤醒被阻塞的读操作 -> 解除互斥锁

func (rw *RWMutex) Unlock() {
	// Announce to readers there is no active writer.
	r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
	if r >= rwmutexMaxReaders {
		race.Enable()
		throw("sync: Unlock of unlocked RWMutex")
	}
	// Unblock blocked readers, if any.
	for i := 0; i < int(r); i++ {
		runtime_Semrelease(&rw.readerSem, false, 0)
	}
	// Allow other writers to proceed.
	rw.w.Unlock()
}

为什么写锁不会被饿死？

写操作到来时，会把 RWMutex.readerCount 值拷贝到 RWMutex.readerWait 中，用于标记排在写操作前面的读者个数

前面的读操作结束后，除了会递减 RWMutex.readerCount，还会递减 RWMutex.readerWait 值，当 RWMutex.readerWait值变为 0 时唤醒写操作

参考文献：《Go专家编程》之rwmutex