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
        // 当前执行读的goroutine的数量

	readerCount int32  // number of pending readers
        // 获取写锁时需要等待的读锁释放数量

	readerWait  int32  // number of departing readers

}

const rwmutexMaxReaders = 1 << 30

// RLock locks rw for reading.

//

// It should not be used for recursive read locking; a blocked Lock

// call excludes new readers from acquiring the lock. See the

// documentation on the RWMutex type.

func (rw *RWMutex) RLock() {

	if race.Enabled {

		_ = rw.w.state

		race.Disable()

	}
        // 调用这个原子方法，原子加 1
        // 如果写锁已经被获取，那么 readercount在 -rwmutexMaxReaders和0之间，这是将请求获取 RLock的 goroutine的挂起
        // 如果写锁没有被获取，那么 readercount大于 0，获取读锁 ，不阻塞。
        // 通过 readerCount判断读锁与写锁互斥，如果存在写锁则挂起goroutine，多个读锁可以并行

	if atomic.AddInt32(&rw.readerCount, 1) < 0 {

		// A writer is pending, wait for it.
                // 这时休眠这个goroutine，等待被唤醒

		runtime_SemacquireMutex(&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() {

	if race.Enabled {

		_ = rw.w.state

		race.ReleaseMerge(unsafe.Pointer(&rw.writerSem))

		race.Disable()

	}
        // 正在读的goroutine数减1
        // 如果小于0，说明 1. 当前有正在等待获取写锁的goroutine或者多次解锁，进入慢速通道
        if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {

		// Outlined slow-path to allow the fast-path to be inlined

		rw.rUnlockSlow(r)

	}

	if race.Enabled {

		race.Enable()

	}

}

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.
   // 如果有正在等待获取写锁的goroutine, 并且当前的read goroutine是最后一个持有读锁的goroutine, 那么通过信号量唤醒等待获取写锁的goroutine.
   if atomic.AddInt32(&rw.readerWait, -1) == 0 {
      // The last reader unblocks the writer.
      runtime_Semrelease(&rw.writerSem, false, 1)
   }
}

// 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.
        // 首先调用互斥锁的 Lock,获取到互斥锁

	rw.w.Lock()

	// Announce to readers there is a pending writer.
        // 阻塞后续的读操作

	r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders

	// Wait for active readers.
        // 如果计算之后仍有其他goroutine获取读锁，，那么调用 runtime_SemacquireMutex 休眠当前的goroutine直到所有的读操作完成

	if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {

		runtime_SemacquireMutex(&rw.writerSem, false, 0)

	}

	if race.Enabled {

		race.Enable()

		race.Acquire(unsafe.Pointer(&rw.readerSem))

		race.Acquire(unsafe.Pointer(&rw.writerSem))

	}

}

// Unlock unlocks rw for writing. It is a run-time error if rw is

// not locked for writing on entry to Unlock.

//

// As with Mutexes, a locked RWMutex is not associated with a particular

// goroutine. One goroutine may RLock (Lock) a RWMutex and then

// arrange for another goroutine to RUnlock (Unlock) it.

func (rw *RWMutex) Unlock() {

	if race.Enabled {

		_ = rw.w.state

		race.Release(unsafe.Pointer(&rw.readerSem))

		race.Disable()

	}

	// Announce to readers there is no active writer.
        // 将 readerCount 恢复

	r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)

	if r >= rwmutexMaxReaders {

		race.Enable()

		throw("sync: Unlock of unlocked RWMutex")

	}

	// Unblock blocked readers, if any.
        // 循环唤醒等待获取读锁的 goroutine

	for i := 0; i < int(r); i++ {

		runtime_Semrelease(&rw.readerSem, false, 0)

	}

	// Allow other writers to proceed.

	rw.w.Unlock()

	if race.Enabled {

		race.Enable()

	}

}