ch9/ch9-03

[giscus[bot]]

ch9/ch9-03

中文版

https://gopl-zh.github.io/ch9/ch9-03.html

[lazybearlee]

sync.RWMutex读写锁

数据竞态是指在并发程序中，两个或更多的操作需要访问同一块内存，并且至少有一个操作是写入，而这些操作在不同的线程中进行，且不受同步机制保护。

要一种特殊类型的锁，其允许多个只读操作并行执行，但写操作会完全互斥。这种锁叫作“多读单写”锁（multiple readers, single writer lock），Go语言提供的这样的锁是sync.RWMutex。

本质上是读者写者模型的Go实现。

以下是加读者锁的源码：

func (rw *RWMutex) RLock() {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	if rw.readerCount.Add(1) < 0 {
		// A writer is pending, wait for it.
		runtime_SemacquireRWMutexR(&rw.readerSem, false, 0)
	}
	if race.Enabled {
		race.Enable()
		race.Acquire(unsafe.Pointer(&rw.readerSem))
	}
}

这里 rw.readerCount.Add(1) 实际是一个原子操作，负责计数当前读者个数。

底层有许多原子操作（Load、CompareAndSwap等等）的实现，每个平台的实现略有差异。

这一部分的 race 库的使用主要是为了检测在读写锁（RWMutex）的读锁（RLock）操作中是否存在数据竞态的情况。

if race.Enabled { _ = rw.w.state race.Disable() } 这段代码的作用是：

1. if race.Enabled检查是否开启了数据竞态检测。如果开启了，那么就执行后面的代码。

2. _ = rw.w.state：用于触发竞态检测器。这行代码尝试读取rw.w.state的值，但并不实际使用这个值。这样做的目的是为了让竞态检测器知道这个位置的内存正在被访问。

3. race.Disable()：这个函数调用会暂时关闭竞态检测。这是因为在接下来的代码中，我们知道我们正在进行的操作是安全的，不会引发数据竞态，因此我们可以暂时关闭竞态检测。

然后在代码的最后，race.Enable() 和 race.Acquire(unsafe.Pointer(&rw.readerSem)) 会重新开启竞态检测，并声明对rw.readerSem的访问，这样竞态检测器就知道这个内存位置已经被安全地访问过了。

而 RWMutex 定义如下：

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 atomic.Int32 // number of pending readers
	readerWait  atomic.Int32 // number of departing readers
}

写者的锁则如下，除了竞态的判断，主要还是互斥获取写者锁、获取读者将至队列信号量（顺带把值降为0或0下）、等待当前读者结束（这一步还会把读者将之队列信号量的值转移到等待队列）：

// Lock locks rw for writing.
// If the lock is already locked for reading or writing,
// Lock blocks until the lock is available.
func (rw *RWMutex) Lock() {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	// First, resolve competition with other writers.
	rw.w.Lock()
	// Announce to readers there is a pending writer.
	r := rw.readerCount.Add(-rwmutexMaxReaders) + rwmutexMaxReaders
	// Wait for active readers.
	if r != 0 && rw.readerWait.Add(r) != 0 {
		runtime_SemacquireRWMutex(&rw.writerSem, false, 0)
	}
	if race.Enabled {
		race.Enable()
		race.Acquire(unsafe.Pointer(&rw.readerSem))
		race.Acquire(unsafe.Pointer(&rw.writerSem))
	}
}

使用 rwmutexMaxReaders 的方式很妙！
这里也有几个比较重要的函数：func runtime_Semrelease(s *uint32, handoff bool, skipframes int)和func runtime_SemacquireRWMutex(s *uint32, lifo bool, skipframes int)。

互斥锁(R)类似于Semacquire，但用于分析争用互斥锁和rwmutex。如果lifo为真，则队列服务员位于等待队列的最前面。skipframes是从runtime_SemacquireMutex的调用者开始计算的，在跟踪期间要忽略的帧数。该函数的不同形式只是告诉运行时如何在回溯中表示等待的原因，并用于计算一些指标。否则它们在功能上是相同的。
Semrelease会自动增加*s，如果一个线程在Semacquire中被阻塞，则会通知等待的例程。它的目的是作为一个简单的唤醒原语供同步库使用，不应该直接使用。如果交接是真的，直接把点数传给第一个服务员。skipframes是跟踪期间要忽略的帧数，从runtime_Semrelease调用者开始计数。