// 基于RWMutex的實(shí)現(xiàn)
var rwLock sync.RWMutex
var str1 = "hello"

func readWithRWLock() string {
    rwLock.RLock()
    defer rwLock.RUnlock()
    return str1
}

func writeWithRWLock() {
    rwLock.Lock()
    str1 = time.Now().Format("20060102150405")
    rwLock.Unlock()
}

// 多個協(xié)程并行讀取string變量，同時每100ms對string變量進(jìn)行1次更新
func BenchmarkRWMutex(b *testing.B) {
    ticker := time.NewTicker(100 * time.Millisecond)
    go func() {
        for range ticker.C {
            writeWithRWLock()
        }
    }()
    b.ResetTimer()
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            readWithRWLock()
        }
    })
}
// 基于Mutex實(shí)現(xiàn)
var lock sync.Mutex
var str2 = "hello"

func readWithMutex() string {
    lock.Lock()
    defer lock.Unlock()
    return str2
}

func writeWithMutex() {
    lock.Lock()
    str2 = time.Now().Format("20060102150405")
    lock.Unlock()
}

// 多個協(xié)程并行讀取string變量，同時每100ms對string變量進(jìn)行1次更新
func BenchmarkMutex(b *testing.B) {
    ticker := time.NewTicker(100 * time.Millisecond)
    go func() {
        for range ticker.C {
            writeWithMutex()
        }
    }()
    b.ResetTimer()
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            readWithMutex()
        }
    })
}

const rwmutexMaxReaders = 1 << 30

type RWMutex struct {
    w           Mutex  // Mutex互斥鎖，用于實(shí)現(xiàn)寫操作之間的互斥

    writerSem   uint32 // 寫操作信號量，用于讀操作喚醒寫操作
    readerSem   uint32 // 讀操作信號量，用于寫操作喚醒讀操作

    readerCount int32  // 讀操作的數(shù)量，不存在寫操作時從0開始計數(shù)，存在寫操作時從-rwmutexMaxReaders開始計數(shù)
    readerWait  int32  // 寫操作等待讀操作的數(shù)量
}

func (rw *RWMutex) Lock() {
    // 寫操作之間通過w互斥鎖實(shí)現(xiàn)互斥
    rw.w.Lock()
    // 1.將readerCount更新為負(fù)值，表示當(dāng)前有寫操作；當(dāng)readerCount為負(fù)數(shù)時，新的讀操作會被掛起
    // 2.r表示當(dāng)前正在執(zhí)行的讀操作數(shù)量
    r := atomic.AddInt32(&rw.readerCount, -rwmutexMaxReaders) + rwmutexMaxReaders
    // r != 0表示當(dāng)前存在正在執(zhí)行的讀操作；寫操作需要等待所有讀操作執(zhí)行完，才能被執(zhí)行；
    if r != 0 && atomic.AddInt32(&rw.readerWait, r) != 0 {
        // 將寫操作掛起
        runtime_SemacquireMutex(&rw.writerSem, false, 0)
    }
}

func (rw *RWMutex) Unlock() {
    // 將readerCount更新為正數(shù)，從0開始計數(shù)
    r := atomic.AddInt32(&rw.readerCount, rwmutexMaxReaders)
    if r >= rwmutexMaxReaders {
        throw("sync: Unlock of unlocked RWMutex")
    }
    // 喚醒所有等待寫操作的讀操作 
    for i := 0; i < int(r); i++ {
        runtime_Semrelease(&rw.readerSem, false, 0)
    }
    // 釋放w互斥鎖，允許其他寫操作進(jìn)入
    rw.w.Unlock()
}

func (rw *RWMutex) RLock() {
    // 原子更新readerCount+1
    // 1. readerCount+1為負(fù)數(shù)時，表示當(dāng)前存在寫操作；讀操作需要等待寫操作執(zhí)行完，才能被執(zhí)行
    // 2. readerCount+1不為負(fù)數(shù)時，表示當(dāng)前不存在寫操作，讀操作可以執(zhí)行
    if atomic.AddInt32(&rw.readerCount, 1) < 0 {
        // 將讀操作掛起
        runtime_SemacquireMutex(&rw.readerSem, false, 0)
    }
}

func (rw *RWMutex) RUnlock() {
    // 原子更新readerCount-1
    // 當(dāng)readerCount-1為負(fù)時，表示當(dāng)前讀操作阻塞了寫操作，需要進(jìn)行readerWait的更新
    if r := atomic.AddInt32(&rw.readerCount, -1); r < 0 {
        rw.rUnlockSlow(r)
    }
}

func (rw *RWMutex) rUnlockSlow(r int32) {
    if r+1 == 0 || r+1 == -rwmutexMaxReaders {
        throw("sync: RUnlock of unlocked RWMutex")
    }
    // 原子操作readerWait-1
    // 當(dāng)readerWait-1為0時，表示導(dǎo)致寫操作阻塞的所有讀操作都執(zhí)行完，將寫操作喚醒
    if atomic.AddInt32(&rw.readerWait, -1) == 0 {
        // 喚醒讀操作
        runtime_Semrelease(&rw.writerSem, false, 1)
    }
}