Source: rwmutex.go in package runtime


package runtime

import (
	"runtime/internal/atomic"
)

This is a copy of sync/rwmutex.go rewritten to work in the runtime.

A rwmutex is a reader/writer mutual exclusion lock. The lock can be held by an arbitrary number of readers or a single writer. This is a variant of sync.RWMutex, for the runtime package. Like mutex, rwmutex blocks the calling M. It does not interact with the goroutine scheduler.

type rwmutex struct {
	rLock      mutex    // protects readers, readerPass, writer
	readers    muintptr // list of pending readers
	readerPass uint32   // number of pending readers to skip readers list

	wLock  mutex    // serializes writers
	writer muintptr // pending writer waiting for completing readers

	readerCount uint32 // number of pending readers
	readerWait  uint32 // number of departing readers
}

const rwmutexMaxReaders = 1 << 30

rlock locks rw for reading.

The reader must not be allowed to lose its P or else other things blocking on the lock may consume all of the Ps and deadlock (issue #20903). Alternatively, we could drop the P while sleeping.

	acquirem()

A writer is pending. Park on the reader queue.

		systemstack(func() {
			lockWithRank(&rw.rLock, lockRankRwmutexR)

Writer finished.

				rw.readerPass -= 1
				unlock(&rw.rLock)

Queue this reader to be woken by the writer.

				m := getg().m
				m.schedlink = rw.readers
				rw.readers.set(m)
				unlock(&rw.rLock)
				notesleep(&m.park)
				noteclear(&m.park)
			}
		})
	}
}

runlock undoes a single rlock call on rw.

func (rw *rwmutex) runlock() {
	if r := int32(atomic.Xadd(&rw.readerCount, -1)); r < 0 {
		if r+1 == 0 || r+1 == -rwmutexMaxReaders {
			throw("runlock of unlocked rwmutex")

A writer is pending.

The last reader unblocks the writer.

			lockWithRank(&rw.rLock, lockRankRwmutexR)
			w := rw.writer.ptr()
			if w != nil {
				notewakeup(&w.park)
			}
			unlock(&rw.rLock)
		}
	}
	releasem(getg().m)
}

lock locks rw for writing.

Resolve competition with other writers and stick to our P.

	lockWithRank(&rw.wLock, lockRankRwmutexW)

Announce that there is a pending writer.

Wait for any active readers to complete.

	lockWithRank(&rw.rLock, lockRankRwmutexR)

Wait for reader to wake us up.

		systemstack(func() {
			rw.writer.set(m)
			unlock(&rw.rLock)
			notesleep(&m.park)
			noteclear(&m.park)
		})
	} else {
		unlock(&rw.rLock)
	}
}

unlock unlocks rw for writing.

Announce to readers that there is no active writer.

	r := int32(atomic.Xadd(&rw.readerCount, rwmutexMaxReaders))
	if r >= rwmutexMaxReaders {
		throw("unlock of unlocked rwmutex")

Unblock blocked readers.

	lockWithRank(&rw.rLock, lockRankRwmutexR)
	for rw.readers.ptr() != nil {
		reader := rw.readers.ptr()
		rw.readers = reader.schedlink
		reader.schedlink.set(nil)
		notewakeup(&reader.park)
		r -= 1

If r > 0, there are pending readers that aren't on the queue. Tell them to skip waiting.

	rw.readerPass += uint32(r)

Allow other writers to proceed.

	unlock(&rw.wLock)