```go
package sync

import (
	"internal/race"
	"sync/atomic"
	"unsafe"
)


type RWMutex struct {
	w           Mutex  // held if there are pending writers
	writerSem   uint32 // 写操作等待读操作完成的信号量
	readerSem   uint32 // 读操作等待写操作完成的信号量
	readerCount int32  // 读的个数
	readerWait  int32  // 写阻塞时读者个数
}

//最大只支持 1 << 30 个读锁
const rwmutexMaxReaders = 1 << 30

/*
RLock 读加锁
	增加读操作计数，即readerCount++
	阻塞等待写操作结束(若有, readerCount<0)
*/
func (rw *RWMutex) RLock() {
	//是否开启检测race
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	//这里分两种情况:
	//1.当判断大于等于0, 证明当前没有写锁, 那么可以上读锁, 并且readerCount原子加1(读锁可重入[只要匹配了释放次数就行])
	//2.当判断小于0, 证明当前有写锁(Lock时会readerCount-rwmutexMaxReaders, 因此会小于0), 所以通过readerSem读信号量, 使读操作睡眠等待
	if atomic.AddInt32(&rw.readerCount, 1) < 0 {
		// 当前有个写锁, 读操作阻塞等待写锁释放
		runtime_SemacquireMutex(&rw.readerSem, false, 0)
	}
	//是否开启检测race
	if race.Enabled {
		race.Enable()
		race.Acquire(unsafe.Pointer(&rw.readerSem))
	}
}

/*
RUnlock 读解锁
	减少读操作计数，即readerCount--
	唤醒等待写操作的协程(若有, readerCount==0)
*/
func (rw *RWMutex) RUnlock() {
	//是否开启检测race
	if race.Enabled {
		_ = rw.w.state
		race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))
		race.Disable()
	}

	//这里分两种情况:
	//释放读锁, readerCount减1
	//1.若readerCount大于0, 证明当前还有读锁, 直接结束本次操作
	//2.若readerCount小于等于0, 证明已经没有读锁, 可以唤醒写锁(若有)
	if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
		// Outlined slow-path to allow the fast-path to be inlined
		rw.rUnlockSlow(r)
	}
	//是否开启检测race
	if race.Enabled {
		race.Enable()
	}
}

func (rw *RWMutex) rUnlockSlow(r int32) {
	//1.本来就没读锁, 调用RUnlock就发生panic
	//2.超过读锁的最大限制就发生panic
	if r+1 == 0 || r+1 == -rwmutexMaxReaders {
		race.Enable()
		throw("sync: RUnlock of unlocked RWMutex")
	}
	// 如果当前有写锁等待
	if atomic.AddInt32(&rw.readerWait, -1) == 0 {
		// 写锁前的最后一个读锁唤醒写锁执行
		runtime_Semrelease(&rw.writerSem, false, 1)
	}
}

/*
Lock 写上锁
	获取互斥锁
	阻塞等待所有读操作结束（若有）
*/
func (rw *RWMutex) Lock() {
	//是否开启检测race
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	//获取互斥锁
	rw.w.Lock()
	// 通知读锁有一个写锁到来
	// readerCount-rwmutexMaxReaders小于0, 再加回rwmutexMaxReaders
	// 若r仍然不为0, 代表当前还有读锁
	r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
	// 等待写锁前面的读锁释放, 所以若不为0就阻塞写锁, 等待rUnlockSlow-rUnlockSlow的readerWait-1直至0倍唤醒写锁
	if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
		//阻塞写锁
		runtime_SemacquireMutex(&rw.writerSem, false, 0)
	}
	//是否开启检测race
	if race.Enabled {
		race.Enable()
		race.Acquire(unsafe.Pointer(&rw.readerSem))
		race.Acquire(unsafe.Pointer(&rw.writerSem))
	}
}

/*
Unlock 写解锁
	唤醒因读锁定而被阻塞的协程（若有）
	解除互斥锁
*/
func (rw *RWMutex) Unlock() {
	//是否开启检测race
	if race.Enabled {
		_ = rw.w.state
		race.Release(unsafe.Pointer(&rw.readerSem))
		race.Disable()
	}

	// 增加readerCount, 若超过读锁的最大限制, 触发panic
	r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
	if r >= rwmutexMaxReaders {
		race.Enable()
		throw("sync: Unlock of unlocked RWMutex")
	}
	// 解除阻塞的读锁(若有)
	for i := 0; i < int(r); i++ {
		runtime_Semrelease(&rw.readerSem, false, 0)
	}

	// 释放互斥锁
	rw.w.Unlock()

	//是否开启检测race
	if race.Enabled {
		race.Enable()
	}
}

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() }
```