How to realize the bottom layer of read-write lock in go question bank 16

*

「 title 」GOLANG ROADMAP Community

*

「 answer 」（ free ）

The bottom layer of read-write lock is based on mutual exclusion .

• Why is there a read-write lock , What problem does it solve ？（ Use scenarios ）
• What is its underlying principle ？

Here I will combine Go Read write lock in RWMutex To introduce .

We're going to talk to Mutex The answer comes from comparison .Mutex It's indistinguishable goroutine For the operation behavior of shared resources , Read operation 、 It will lock , Writing operations , It will also be locked , When for a while , Most of the reading operations , Read operation in Mutex Under the protection of, it has to become serial access , The impact on performance is relatively large .

RWMutex The birth of read-write lock is to distinguish read-write operations , When reading ,goroutine There is no need to wait foolishly , Instead, you can access shared resources concurrently , Turn serial reading into parallel reading , Improves the performance of read operations .

Read write locks are designed to solve a class of problems ：readers-writes , When there are multiple read or write operations at the same time , As long as there is a thread performing write operations , Other threads cannot read .

There are actually three working models of read-write locks ：

• Read-perferring
 Read design first , May cause hunger
• Write-prferring
 Write design first , Avoid writing about hunger
• Don't assign priority 
 Don't prioritize , Solve the problem of hunger

Go Read write lock in , The working model is Write-prferring programme .

「 answer 」（ Luanlongsheng ）

1. Read write lock solves the problem

   Mainly used for less write operations , Scenarios with many read operations . Read / write locks meet the following four rules .

   • Write lock needs to block write lock ： When a coroutine has a write lock , Other coroutine write locks need to be blocked ;
   • Write lock needs to block read lock ： When a coroutine has a write lock , Other coprocessor read locks need to be blocked ;
   • Read lock needs to block write lock ： When a coroutine has a read lock , Other coroutine write locks need to be blocked ;
   • Read lock cannot block read lock ： When a coroutine has a read lock , Other coroutines can also have read locks .

2. The bottom implementation of read-write lock

   There is still a mutex inside the read-write lock , Used to isolate multiple writes , The others are used to isolate read and write operations .

   Source package src/sync/rmmutex.go:RWMutex The data structure of read-write lock is defined in

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