// RWMutex 結(jié)構(gòu)體包含了用于讀寫(xiě)互斥鎖的各種狀態(tài)和信號(hào)量。在 RWMutex 中，多個(gè) goroutine 可以同時(shí)持有讀鎖，
// 但只有一個(gè) goroutine 可以持有寫(xiě)鎖。RWMutex 的實(shí)現(xiàn)確保了在寫(xiě)鎖等待的情況下，新的讀鎖無(wú)法被獲取，
// 從而防止了讀鎖長(zhǎng)時(shí)間等待
type RWMutex struct {
    w           Mutex        // 用于寫(xiě)鎖的互斥鎖
    writerSem   uint32       // 寫(xiě)鎖的信號(hào)量，用于等待讀鎖完成
    readerSem   uint32       // 讀鎖的信號(hào)量，用于等待寫(xiě)鎖完成
    readerCount atomic.Int32 // 讀者持有讀者鎖的數(shù)量
    readerWait  atomic.Int32 // 寫(xiě)者等待讀鎖的數(shù)量
}
// readerCount 
// 當(dāng)讀者加鎖時(shí)， readerCount  +1 
// 當(dāng)讀者解鎖時(shí)， readerCount  -1
// 當(dāng) readerCount 大于 0 時(shí)，表示有讀者持有讀鎖。
// 如果 readerCount 等于 0，則表示當(dāng)前沒(méi)有讀者持有讀鎖。
// 當(dāng) readerCount 等于 0 時(shí)，其他寫(xiě)者可以嘗試獲取寫(xiě)鎖
// 當(dāng) readerCount < 0 , 說(shuō)明有寫(xiě)者在等待， 讀者需要等待寫(xiě)者釋放寫(xiě)鎖
// readerWait（寫(xiě)者等待讀鎖的數(shù)量）：
// 當(dāng)寫(xiě)者嘗試獲取寫(xiě)鎖，但當(dāng)前有讀者持有讀鎖時(shí)，寫(xiě)者會(huì)被阻塞，并且 readerWait 會(huì)增加。
// 當(dāng)讀者釋放讀鎖時(shí)，如果有寫(xiě)者在等待讀鎖，readerWait 會(huì)減少，并且可能喚醒等待的寫(xiě)者
// readerCount > 0：表示有讀者持有讀鎖。
// readerCount == 0 且 readerWait > 0：表示有寫(xiě)者在等待讀鎖，阻塞中。
// readerCount == 0 且 readerWait == 0：表示當(dāng)前沒(méi)有讀者持有讀鎖，且沒(méi)有寫(xiě)者在等待讀鎖。此時(shí)其他寫(xiě)者可以嘗試獲取寫(xiě)鎖。
// 這樣的設(shè)計(jì)是為了在寫(xiě)者等待讀鎖時(shí)，不允許新的讀者加入，以確保寫(xiě)者獲得更公平的機(jī)會(huì)。

// Happens-before relationships are indicated to the race detector via:
// - Unlock  -> Lock:  readerSem
// - Unlock  -> RLock: readerSem
// - RUnlock -> Lock:  writerSem
//
// happends-before 用于描述時(shí)間發(fā)生的順序，在 這里 （代碼中的注釋）
// Unlock 事件發(fā)生之前（happens-before）的 Lock 事件。
// Unlock 事件發(fā)生之前（happens-before）的 RLock 事件。
// RUnlock 事件發(fā)生之前（happens-before）的 Lock 事件


func (rw *RWMutex) RLock() {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	// 它將 readerCount 增加 1。如果結(jié)果小于 0，說(shuō)明有一個(gè)寫(xiě)者拿著鎖了， 這邊需要等著
	if rw.readerCount.Add(1) < 0 {
		// A writer is pending, wait for it.
		// 在讀寫(xiě)鎖的情況下 執(zhí)行鎖的信號(hào)量 
		// 實(shí)際得等待操作， 調(diào)用底層代碼， 等寫(xiě)者釋放鎖
		runtime_SemacquireRWMutexR(&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.
func (rw *RWMutex) RUnlock() {
	... // 競(jìng)態(tài)規(guī)則邏輯
	// readerCount 用于記錄當(dāng)前持有讀鎖的讀者數(shù)量。如果讀者計(jì)數(shù)減為負(fù)數(shù)，說(shuō)明存在寫(xiě)者正在等待讀鎖釋放
	if r := rw.readerCount.Add(-1); r < 0 {
		// Outlined slow-path to allow the fast-path to be inlined
		rw.rUnlockSlow(r)
	}
	... // 競(jìng)態(tài)規(guī)則邏輯
}
func (rw *RWMutex) rUnlockSlow(r int32) {
	... // 競(jìng)態(tài)規(guī)則邏輯
	// A writer is pending.
	// 減少讀者等待計(jì)數(shù)。readerWait 記錄正在等待讀鎖釋放的讀者數(shù)量。如果讀者等待計(jì)數(shù)減為零，
	// 說(shuō)明最后一個(gè)讀者已經(jīng)釋放了讀鎖，可以喚醒等待的寫(xiě)者
	if rw.readerWait.Add(-1) == 0 {
		// The last reader unblocks the writer.
		// 釋放寫(xiě)者的信號(hào)量
		runtime_Semrelease(&rw.writerSem, false, 1)
	}
}

func (rw *RWMutex) Lock() {
	... // 競(jìng)態(tài)規(guī)則邏輯
	// First, resolve competition with other writers.
	// 獲取寫(xiě)鎖，解決與其他寫(xiě)者的競(jìng)爭(zhēng)
	rw.w.Lock()
	// Announce to readers there is a pending writer.
	// 將 readerCount 減去 rwmutexMaxReaders，然后再加上 rwmutexMaxReaders，目的是將 readerCount 設(shè)置為負(fù)數(shù)，
	// 表示有一個(gè)寫(xiě)者正在等待寫(xiě)鎖。這會(huì)通過(guò) readerWait 記錄下來(lái)，并用于通知讀者和寫(xiě)者。
	// 這邊得  rw.readerCount 是一個(gè)負(fù)數(shù)， 在RLock 中有個(gè)判斷 rw.readerCount <0 , 
	// 這一段就是實(shí)現(xiàn)了寫(xiě)者優(yōu)先， 不管當(dāng)前有沒(méi)有讀者拿著讀鎖， 接下來(lái)拿鎖的讀鎖， 統(tǒng)統(tǒng)排我后面，不能影響我（寫(xiě)者）， 等我（寫(xiě)者）處理完了再說(shuō)
	r := rw.readerCount.Add(-rwmutexMaxReaders) + rwmutexMaxReaders
	// Wait for active readers.
	// 如果有活躍的讀者，且將 readerWait 增加 r 后不為零，說(shuō)明有讀者正在等待讀鎖釋放
	if r != 0 && rw.readerWait.Add(r) != 0 {
	// 獲取寫(xiě)鎖。
	// 它不是馬上就能獲取寫(xiě)鎖，而是可能會(huì)被阻塞，需要等待寫(xiě)鎖的釋放
	// 當(dāng)寫(xiě)者執(zhí)行這個(gè)操作時(shí)，如果當(dāng)前沒(méi)有其他寫(xiě)者或讀者持有鎖，那么它會(huì)成功獲取寫(xiě)鎖，否則它會(huì)被阻塞，直到?jīng)]有其他寫(xiě)者或讀者持有鎖
		runtime_SemacquireRWMutex(&rw.writerSem, false, 0)
	}
	... // 競(jìng)態(tài)規(guī)則邏輯
}

// arrange for another goroutine to RUnlock (Unlock) it.
func (rw *RWMutex) Unlock() {
	... // 競(jìng)態(tài)規(guī)則邏輯

	// Announce to readers there is no active writer.
	// 將 readerCount 增加 rwmutexMaxReaders，用于通知活躍的讀者，寫(xiě)者已經(jīng)釋放了寫(xiě)鎖
	// 我（ 寫(xiě)者）處理完了， 把 rw.readerCount 加回來(lái)了， 當(dāng)前寫(xiě)鎖寫(xiě)完了， 剛剛我（寫(xiě)者）拿鎖以后 申請(qǐng)的讀鎖們， 可以喚醒了
	r := rw.readerCount.Add(rwmutexMaxReaders)
	... // 競(jìng)態(tài)規(guī)則邏輯
	// Unblock blocked readers, if any.
	// 遍歷并逐個(gè)釋放等待的讀者，通過(guò) runtime_Semrelease 信號(hào)量操作通知它們。
	for i := 0; i < int(r); i++ {
		runtime_Semrelease(&rw.readerSem, false, 0)
	}
	// Allow other writers to proceed.
	rw.w.Unlock()
	... // 競(jìng)態(tài)規(guī)則邏輯
}