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

// Happens-before relationships are indicated to the race detector via:
// - Unlock  -> Lock:  readerSem
// - Unlock  -> RLock: readerSem
// - RUnlock -> Lock:  writerSem
//
// happends-before 用于描述時間發(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，說明有一個寫者拿著鎖了， 這邊需要等著
	if rw.readerCount.Add(1) < 0 {
		// A writer is pending, wait for it.
		// 在讀寫鎖的情況下 執(zhí)行鎖的信號量 
		// 實際得等待操作， 調(diào)用底層代碼， 等寫者釋放鎖
		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() {
	... // 競態(tài)規(guī)則邏輯
	// readerCount 用于記錄當(dāng)前持有讀鎖的讀者數(shù)量。如果讀者計數(shù)減為負(fù)數(shù)，說明存在寫者正在等待讀鎖釋放
	if r := rw.readerCount.Add(-1); r < 0 {
		// Outlined slow-path to allow the fast-path to be inlined
		rw.rUnlockSlow(r)
	}
	... // 競態(tài)規(guī)則邏輯
}
func (rw *RWMutex) rUnlockSlow(r int32) {
	... // 競態(tài)規(guī)則邏輯
	// A writer is pending.
	// 減少讀者等待計數(shù)。readerWait 記錄正在等待讀鎖釋放的讀者數(shù)量。如果讀者等待計數(shù)減為零，
	// 說明最后一個讀者已經(jīng)釋放了讀鎖，可以喚醒等待的寫者
	if rw.readerWait.Add(-1) == 0 {
		// The last reader unblocks the writer.
		// 釋放寫者的信號量
		runtime_Semrelease(&rw.writerSem, false, 1)
	}
}

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

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

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