老鸭窝视频在线观看,欧美成人免费一区二区,乱vodafonewifi熟妇

快捷導(dǎo)航

golang RWMutex讀寫鎖實現(xiàn)讀共享寫?yīng)氄嫉墓δ苁纠?/h1>

更新時間：2023年09月27日 09:22:57 作者：lincoln_hlf1

在 Go 里除了互斥鎖外,還有讀寫鎖 RWMutex,它主要用來實現(xiàn)讀共享,寫?yīng)氄嫉墓δ?今天我們也順便分析下讀寫鎖,加深對 Go 鎖的理解

引言

在上一篇文章 golang 重要知識：mutex 里我們介紹了互斥鎖 mutex 的相關(guān)原理實現(xiàn)。而且在 Go 里除了互斥鎖外，還有讀寫鎖 RWMutex，它主要用來實現(xiàn)讀共享，寫?yīng)氄嫉墓δ?。今天我們也順便分析下讀寫鎖，加深對 Go 鎖的理解

讀寫鎖的實現(xiàn)原理

所謂的讀寫鎖，其實就是針對下面的兩種場景，對 Goroutine 之間的同步互斥進行控制：

多個 goroutine 一起占有讀鎖，互不影響，可以繼續(xù)自己后面的邏輯代碼。
寫鎖正在占有著，則后面的 goroutine 無論是要進行讀鎖占有，還是寫鎖占有，都將會被阻塞等待，直到當前的寫鎖釋放。

弄清楚上面的場景需求后，實現(xiàn)就簡單多了，關(guān)鍵就在于判斷當前是否處于寫鎖狀態(tài)即可，畢竟需要有阻塞等待的動作。

按照常規(guī)思路，我們一般會采用一個標識位來維護這個狀態(tài)。然而，Go 官方卻連這一步都省了。

利用了一個本來就得維護的讀鎖數(shù)量，在進行寫鎖占有時，使它變?yōu)樨摂?shù)。

后面有新進來的讀寫操作，只需要判斷該值是否正負即可，負數(shù)則代表當前正在進行寫鎖占有，需要阻塞等待。

而在寫鎖占有結(jié)束后，該值又會恢復(fù)為正數(shù)，又可以進行新的讀寫操作了。

RWMutex 源碼分析

接下來，我們到 src/runtime/rwmutex.go里具體分析下 RWMutex 的代碼結(jié)構(gòu)。

// rwmutex 是一個讀寫互斥的鎖
// 將允許多個 goroutine 持有讀鎖，但寫鎖只會有一個持有
// rwmutex 使用了 sync.RWMutex 來輔助寫鎖互斥
type rwmutex struct {
rLock      mutex    // 用于保護設(shè)置 readers, readerPass, writer
readers    muintptr // 休眠等待的 goroutine 讀鎖隊列，等到寫鎖占有結(jié)束后將對應(yīng)被喚起。
readerPass uint32   // 讀鎖隊列需要跳過的 goroutine 數(shù)量，當在寫鎖結(jié)束后會喚起讀鎖隊列里的 goroutine，但有的可能已不在隊列里了，這部分需跳過。
wLock  mutex    // 用于 writer 之間的互斥鎖
writer muintptr // 等待讀完成的 writer
readerCount uint32 // 正在執(zhí)行讀操作的 goroutine數(shù)量
readerWait  uint32 // 等待讀鎖釋放的數(shù)量。當寫鎖占有后，前面還有部分讀鎖在繼續(xù)著，需要等它們釋放才能繼續(xù)進行。
}

RWMutex 的 Lock() 分析

func (rw *rwmutex) Lock() {
    // 用于多個寫鎖之間的的競爭
    lock(&rw.wLock)
    m := getg().m
    // 將讀鎖數(shù)量 readerCount 置為負數(shù)，用于判斷當前是否處于寫鎖占有狀態(tài)，
    // rw.readerCount < 0 則表示當前正在進行寫鎖占有.
    r := int32(atomic.Xadd(&rw.readerCount, -rwmutexMaxReaders)) + rwmutexMaxReaders
    // 前面還有讀鎖在進行著，需要等待釋放完才能繼續(xù)
    lock(&rw.rLock)
    if r != 0 && atomic.Xadd(&rw.readerWait, r) != 0 {
        systemstack(func() {
            rw.writer.set(m)
            unlock(&rw.rLock)
            notesleep(&m.park)
            noteclear(&m.park)
        })
    } else {
        unlock(&rw.rLock)
    }
}

RWMutex 的 RLock() 分析

func (rw *rwmutex) Rlock() {
    acquirem()
    if int32(atomic.Xadd(&rw.readerCount, 1)) < 0 {
        // 讀鎖數(shù)量 readerCount + 1 后小于 0，表示當前正被寫鎖占有，
        // 等待寫鎖釋放
        systemstack(func() {
            lock(&rw.rLock)
            if rw.readerPass > 0 {
                rw.readerPass -= 1
                unlock(&rw.rLock)
            } else {
                // 等待寫鎖喚起
                m := getg().m
                m.schedlink = rw.readers
                rw.readers.set(m)
                unlock(&rw.rLock)
                notesleep(&m.park)
                noteclear(&m.park)
            }
        })
    }
}

RWMutex 的 Unlock() 分析

func (rw *rwmutex) Unlock() {
    // 將原來被寫鎖置為負數(shù)的 readerCount 重新恢復(fù)回來.
    r := int32(atomic.Xadd(&rw.readerCount, rwmutexMaxReaders))
    if r >= rwmutexMaxReaders {
        throw("unlock of unlocked rwmutex")
    }
    // 喚起之前等待的讀鎖.
    lock(&rw.rLock)
    for rw.readers.ptr() != nil {
        reader := rw.readers.ptr()
        rw.readers = reader.schedlink
        reader.schedlink.set(nil)
        notewakeup(&reader.park)
        r -= 1
    }
    // 如果 r > 0, 說明讀鎖隊列里有的 goroutine 已不在隊列里了，這部分需跳過
    rw.readerPass += uint32(r)
    unlock(&rw.rLock)
    // 解除寫鎖
    unlock(&rw.wLock)
}

RWMutex 的 RUnlock() 分析

func (rw *rwmutex) RUnlock() {
    // 如果釋放后，readerCount < 0，表示當前寫鎖正在占有
    if r := int32(atomic.Xadd(&rw.readerCount, -1)); r < 0 {
        if r+1 == 0 || r+1 == -rwmutexMaxReaders {
            throw("runlock of unlocked rwmutex")
        }
        // readerWait == 0，表示前面的讀鎖都釋放完了，
        // 需要喚起寫鎖
        if atomic.Xadd(&rw.readerWait, -1) == 0 {
            // The last reader unblocks the writer.
            lock(&rw.rLock)
            w := rw.writer.ptr()
            if w != nil {
                notewakeup(&w.park)
            }
            unlock(&rw.rLock)
        }
    }
    releasem(getg().m)
}