概述

信號量是并發(fā)編程中常見的一種同步機制，在需要控制訪問資源的進程數(shù)量時就會用到信號量，它會保證持有的計數(shù)器在 0 到初始化的權(quán)重之間波動。

• 每次獲取的資源都會將信號量中的計數(shù)器減去對應(yīng)的數(shù)值，在釋放時重新加回來
• 當遇到計數(shù)器大于信號量大小時，會進入休眠等待其他線程釋放信號

Go語言的擴展包中提供了帶權(quán)重的信號量 semaphore.Weighted，我們可以按照不同的權(quán)重管理資源的訪問，這種結(jié)構(gòu)體暴露了 4 個方法：

• semaphore.NewWeighted —— 用于創(chuàng)建新的信號量
• semaphore.Weighted.Acquire —— 阻塞地獲取指定權(quán)重的資源，如果當前沒有空閑資源，會陷入休眠等待
• semaphore.Weighted.TryAcquire —— 非阻塞地獲取指定權(quán)重的資源，如果當前沒有空閑資源，會直接返回 false
• semaphore.Weighted.Relesae —— 用于釋放指定權(quán)重的資源

結(jié)構(gòu)體

semaphore.NewWeighted 方法能提供傳入的大量權(quán)重創(chuàng)建一個指向 semaphore.Weighted 結(jié)構(gòu)體的指針：

func NewWeighted(n int64) *Weighted {
    w := &Weighted{size: n}
    return w
}
type Weighted struct {
    size    int64
    cur     int64
    mu      sync.Mutex
    waiters list.list
}

semaphore.Weighted 結(jié)構(gòu)體中包含一個 waiters 列表，其中存儲著等待獲取資源的 Goroutine。除此之外，它還包含當前信號量的上限以及一個計數(shù)器 cur， 這個計數(shù)器的范圍就是 [0,size]

信號量中的計數(shù)器會隨著用戶對資源的訪問和釋放而改變，引入的權(quán)重概念能夠提供更細粒度的資源訪問控制，盡可能滿足常見用例。

獲取

semaphore.Weighted.Acquire 方法能用于獲取指定權(quán)重的資源，其中包含 3 中情況：

• 當信號量中剩余資源大于獲取的資源并且沒有等待的 Goroutine 時，會直接獲取信號量
• 當需要獲取的信號量大于 semaphore.Weighted 的上限時，由于不可能滿足條件，因此會直接返回錯誤
• 遇到其他情況時，會將當前 Goroutine 加入等待列表，并通過 select 等待調(diào)度器喚醒當前 Goroutine，Goroutine 被喚醒后會獲取信號量

func (s *Weighted) Acquire(ctx context.Context, n int64) error {
    if s.size - s.cur >= n && len(s.waiters) == 0 {
        s.cur += n
        return nil
    }
    ...
    ready := make(chan struct{})
    w := waiter{n: n, ready: ready}
    elem := s.waiters.PushBack(w)
    select {
    case <-ctx.Done():
        err := ctx.Err()
        select {
        case <-ready:
            err = nil
        default:
            s.waiters.Remove(elem)
        }
        return err
    case <-ready:
        return nil
    }
}

另一個用于獲取信號量的方法 semaphore.Weighted.TryAcquire 只會非阻塞地判斷當前信號量是否有充足的資源，如果有，會立刻返回 true， 否則會返回 false ：

func (s *Weighted) TryAcquire(n int64) bool {
    s.mu.Lock()
    success := s.size-s.cur >= n && len(s.waiters) == 0
    if success {
        s.cur += n
    }
    s.mu.Unlock()
    return success
}

因為 semaphore.Weighted.TryAcquire 不會等待資源的釋放，所以可能更適用于一些對延時敏感、用戶需要立刻感知結(jié)果的場景

釋放

當我們要釋放信號量時，semaphore.Weighted.Relesae 方法會從頭到尾遍歷 waiters 列表中全部的等待者，如果釋放資源后的信號量有充足的剩余資源，就會通過 Channel 喚醒指定的 Goroutine：

func (c *Weighted) Relesae(n int64) {
    s.mu.Lock()
    s.cur -= n
    for {
        next := w.waiters.Front()
        if next == nil {
            break
        }
        w := next.Value.(waiter)
        if s.size-s.cur < w.n {
            break
        }
        s.cur += w.n
        s.waiters.Remove(next)
        close(w.ready)
    }
    s.mu.Unlock()
}

當然，也可能會出現(xiàn)剩余資源無法喚醒 Channel 的情況，這時當前方法釋放鎖之后會直接返回。

通過 semaphore.Weighted.Relesae 的分析我們可以發(fā)現(xiàn)，如果一個信號量需要占用的資源非常多，它可能會長時間無法獲取鎖，這也是 semaphore.Weighted.Acquire 引入上下文參數(shù)的原因，即為信號量的獲取設(shè)置超時時間。

小結(jié)

帶權(quán)重的信號量確實有更多的應(yīng)用場景，，這也是Go語言對外提供的唯一信號量實現(xiàn)，使用過程中需要注意以下幾個問題：

• semaphore.Weighted.Acquire 和 semaphore.Weighted.TryAcquire 都可以適用于獲取資源，前者會阻塞獲取信號量，后者會非阻塞獲取信號量
• semaphore.Weighted.Relesae 方法會按照先進先出的順序喚醒可以被喚醒的 Goroutine
• 如果一個 Goroutine 獲取了較多的資源，由于 semaphore.Weighted.Relesae 的釋放策略可能會等待較長時間

到此這篇關(guān)于Go語言擴展原語之Semaphore的用法詳解的文章就介紹到這了,更多相關(guān)Go語言Semaphore內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論