RWMutex

type RWMutex struct {
	w           Mutex        
	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
}
 
const rwmutexMaxReaders = 1 << 30
 

func (rw *RWMutex) RLock() {
	if rw.readerCount.Add(1) < 0 {
		// A writer is pending, wait for it.
		runtime_SemacquireRWMutexR(&rw.readerSem, false, 0)
	}
}

func (rw *RWMutex) RUnlock() {
	if r := rw.readerCount.Add(-1); r < 0 {
		// Outlined slow-path to allow the fast-path to be inlined
		rw.rUnlockSlow(r)
	}
}

func (rw *RWMutex) rUnlockSlow(r int32) {
	// A writer is pending.
	if rw.readerWait.Add(-1) == 0 {
		// The last reader unblocks the writer.
		runtime_Semrelease(&rw.writerSem, false, 1)
	}
}

func (rw *RWMutex) Lock() {
	// 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)
	}
}
 

func (rw *RWMutex) Unlock() {
	r := rw.readerCount.Add(rwmutexMaxReaders) 
	for i := 0; i < int(r); i++ {
		runtime_Semrelease(&rw.readerSem, false, 0)
	}
	// Allow other writers to proceed.
	rw.w.Unlock()
}

func (rw *RWMutex) TryLock() bool {
	if !rw.w.TryLock() {
		return false
	}
	if !rw.readerCount.CompareAndSwap(0, -rwmutexMaxReaders) {
		rw.w.Unlock()
		return false
	}
	return true
}

func (rw *RWMutex) TryRLock() bool {
	for {
		c := rw.readerCount.Load()
		if c < 0 {
			return false
		}
		if rw.readerCount.CompareAndSwap(c, c+1) {
			return true
		}
	}
}

package main
 
import (
	"fmt"
	"sync"
	"sync/atomic"
	"time"
	"unsafe"
)
 
const (
	mutexLocked = 1 << iota //枷鎖標誌位
	mutexWoken //喚醒標誌
	mutexStarving // 飢餓狀態
	mutexWaiterShift = iota // waiter開始的位
)
 
type RWMutex struct {
	sync.RWMutex
}
 
type m struct {
	w           sync.Mutex
	writerSem   uint32
	readerSem   uint32
	readerCount atomic.Int32
	readerWait  atomic.Int32
}
 
const rwmutexMaxReaders = 1 << 30
 
func (rw *RWMutex) ReaderCount() int {
	v := (*m)(unsafe.Pointer(&rw.RWMutex))
	r := v.readerCount.Load()
	if r < 0 {
		r += rwmutexMaxReaders
	}
	return int(r)
}
func (rw *RWMutex) ReaderWait() int {
	v := (*m)(unsafe.Pointer(&rw.RWMutex))
	r := v.readerWait.Load()
	return int(r)
}
func (rw *RWMutex) WriterCount() int {
	v := atomic.LoadInt32((*int32)(unsafe.Pointer(&rw.RWMutex)))
	v = v >> mutexWaiterShift
	v = v + (v & mutexLocked)
	return int(v)
}
func main() {
	var mu RWMutex
	for i := 0 ; i < 100 ; i++ {
		go func ()  {
			mu.RLock()
			time.Sleep(time.Hour)
			mu.RUnlock()	
		}()
	}
 
	time.Sleep(time.Second)
 
	for i := 0; i< 50; i++ {
		go func ()  {
			mu.Lock()
			time.Sleep(time.Hour)
			mu.Unlock()	
		}()
	}
	time.Sleep(time.Second)
	
	for i := 0; i< 50; i++ {
		go func ()  {
			mu.RLock()
			time.Sleep(time.Hour)
			mu.RUnlock()	
		}()
	}
 
	time.Sleep(time.Second)
 
	fmt.Println("reader:",mu.ReaderCount())
	fmt.Println("departing reader:",mu.ReaderWait())
	fmt.Println("writer:",mu.WriterCount())
}