concurrency-readers-writers

Answer

Approach 1: sync.RWMutex (Standard Library)

Go's built-in sync.RWMutex directly solves the readers-writers problem. Readers call RLock()/RUnlock() for shared access; writers call Lock()/Unlock() for exclusive access. The standard library implementation is writer-preferring by default — if a writer is waiting, new readers are blocked, preventing writer starvation.

var rw sync.RWMutex
var data int64

// Reader goroutine
rw.RLock()
_ = data  // safe shared read
rw.RUnlock()

// Writer goroutine  
rw.Lock()
data++   // exclusive write
rw.Unlock()

Approach 2: Channel-based RWMutex (From Scratch)

The custom implementation uses a single scheduler goroutine that processes lock/unlock requests via channels. It maintains internal queues and uses a writer-priority policy:

Key design points: - A scheduler goroutine runs a select loop on the three request/release channels - dispatch() grants writers exclusively when the lock is completely free - Writer-priority: if any writer is queued, dispatch() skips granting new readers, draining the writer queue first - Readers are granted in batches (all queued readers when the lock is read-free) - Release events decrement activeReaders or clear activeWriter, then re-dispatch

type ChannelRWMutex struct {
    readReq  chan readRequest
    writeReq chan writeRequest
    release  chan struct{}
    stop     chan struct{}
    wg       sync.WaitGroup
}

func (rw *ChannelRWMutex) RLock() {
    resp := make(chan struct{})
    rw.readReq <- readRequest{resp: resp}
    <-resp
}

func (rw *ChannelRWMutex) Lock() {
    resp := make(chan struct{})
    rw.writeReq <- writeRequest{resp: resp}
    <-resp
}

The scheduler dispatch() function:

dispatch := func() {
    // Grant all queued writers (only when lock is completely free)
    for len(pendingWriters) > 0 && activeReaders == 0 && !activeWriter {
        ch := pendingWriters[0]
        pendingWriters = pendingWriters[1:]
        activeWriter = true
        ch <- struct{}{}
    }
    // Grant all queued readers (only if no writer is active)
    for len(pendingReaders) > 0 && !activeWriter {
        ch := pendingReaders[0]
        pendingReaders = pendingReaders[1:]
        activeReaders++
        ch <- struct{}{}
    }
}