快捷導(dǎo)航

Golang分布式鎖詳細介紹

更新時間：2022年10月11日 10:11:42 作者：~龐貝

分布式鎖是控制分布式系統(tǒng)之間同步訪問共享資源的一種方式。如果不同的系統(tǒng)或是同一個系統(tǒng)的不同主機之間共享了一個或一組資源，那么訪問這些資源時，需要通過一些互斥手段來防止彼此之間的干擾以保證一致性，在這種情況下，就需要使用分布式鎖了

進程內(nèi)加鎖

想要得到正確的結(jié)果的話，把對 counter 的操作代碼部分加上鎖：

// ... 省略之前部分
var wg sync.WaitGroup
var l sync.Mutex
for i := 0; i < 1000; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        l.Lock()
        counter++
        l.Unlock()
    }()
}
wg.Wait()
println(counter)
// ... 省略之后部分

這樣就可以穩(wěn)定地得到計算結(jié)果了：

??? go run local_lock.go
1000

trylock

package main
import (
    "sync"
)
// Lock try lock
type Lock struct {
    c chan struct{}
}
// NewLock generate a try lock
func NewLock() Lock {
    var l Lock
    l.c = make(chan struct{}, 1)
    l.c <- struct{}{}
    return l
}
// Lock try lock, return lock result
func (l Lock) Lock() bool {
    lockResult := false
    select {
    case <-l.c:
        lockResult = true
    default:
    }
    return lockResult
}
// Unlock , Unlock the try lock
func (l Lock) Unlock() {
    l.c <- struct{}{}
}
var counter int
func main() {
    var l = NewLock()
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            if !l.Lock() {
                // log error
                println("lock failed")
                return
            }
            counter++
            println("current counter", counter)
            l.Unlock()
        }()
    }
    wg.Wait()
}

因為我們的邏輯限定每個 goroutine 只有成功執(zhí)行了 Lock 才會繼續(xù)執(zhí)行后續(xù)邏輯，因此在 Unlock 時可以保證 Lock struct 中的 channel 一定是空，從而不會阻塞，也不會失敗。

在單機系統(tǒng)中，trylock 并不是一個好選擇。因為大量的 goroutine 搶鎖可能會導(dǎo)致 cpu 無意義的資源浪費。有一個專有名詞用來描述這種搶鎖的場景：活鎖。

活鎖指的是程序看起來在正常執(zhí)行，但實際上 cpu 周期被浪費在搶鎖，而非執(zhí)行任務(wù)上，從而程序整體的執(zhí)行效率低下?；铈i的問題定位起來要麻煩很多。所以在單機場景下，不建議使用這種鎖。

基于redis的setnx

package main
import (
    "fmt"
    "sync"
    "time"
    "github.com/go-redis/redis"
)
func incr() {
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "", // no password set
        DB:       0,  // use default DB
    })
    var lockKey = "counter_lock"
    var counterKey = "counter"
    // lock
    resp := client.SetNX(lockKey, 1, time.Second*5)
    lockSuccess, err := resp.Result()
    if err != nil || !lockSuccess {
        fmt.Println(err, "lock result: ", lockSuccess)
        return
    }
    // counter ++
    getResp := client.Get(counterKey)
    cntValue, err := getResp.Int64()
    if err == nil {
        cntValue++
        resp := client.Set(counterKey, cntValue, 0)
        _, err := resp.Result()
        if err != nil {
            // log err
            println("set value error!")
        }
    }
    println("current counter is ", cntValue)
    delResp := client.Del(lockKey)
    unlockSuccess, err := delResp.Result()
    if err == nil && unlockSuccess > 0 {
        println("unlock success!")
    } else {
        println("unlock failed", err)
    }
}
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            incr()
        }()
    }
    wg.Wait()
}

看看運行結(jié)果：

??? go run redis_setnx.go
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
<nil> lock result: false
current counter is 2028
unlock success!

通過代碼和執(zhí)行結(jié)果可以看到，我們遠程調(diào)用 setnx 實際上和單機的 trylock 非常相似，如果獲取鎖失敗，那么相關(guān)的任務(wù)邏輯就不應(yīng)該繼續(xù)向前執(zhí)行。

setnx 很適合在高并發(fā)場景下，用來爭搶一些“唯一”的資源。比如交易撮合系統(tǒng)中賣家發(fā)起訂單，而多個買家會對其進行并發(fā)爭搶。這種場景我們沒有辦法依賴具體的時間來判斷先后，因為不管是用戶設(shè)備的時間，還是分布式場景下的各臺機器的時間，都是沒有辦法在合并后保證正確的時序的。哪怕是我們同一個機房的集群，不同的機器的系統(tǒng)時間可能也會有細微的差別。

所以，我們需要依賴于這些請求到達 redis 節(jié)點的順序來做正確的搶鎖操作。如果用戶的網(wǎng)絡(luò)環(huán)境比較差，那也只能自求多福了。

基于zk

package main
import (
    "time"
    "github.com/samuel/go-zookeeper/zk"
)
func main() {
    c, _, err := zk.Connect([]string{"127.0.0.1"}, time.Second) //*10)
    if err != nil {
        panic(err)
    }
    l := zk.NewLock(c, "/lock", zk.WorldACL(zk.PermAll))
    err = l.Lock()
    if err != nil {
        panic(err)
    }
    println("lock succ, do your business logic")
    time.Sleep(time.Second * 10)
    // do some thing
    l.Unlock()
    println("unlock succ, finish business logic")
}

基于 zk 的鎖與基于 redis 的鎖的不同之處在于 Lock 成功之前會一直阻塞，這與我們單機場景中的 mutex.Lock 很相似。

其原理也是基于臨時 sequence 節(jié)點和 watch api，例如我們這里使用的是 /lock 節(jié)點。Lock 會在該節(jié)點下的節(jié)點列表中插入自己的值，只要節(jié)點下的子節(jié)點發(fā)生變化，就會通知所有 watch 該節(jié)點的程序。這時候程序會檢查當(dāng)前節(jié)點下最小的子節(jié)點的 id 是否與自己的一致。如果一致，說明加鎖成功了。

這種分布式的阻塞鎖比較適合分布式任務(wù)調(diào)度場景，但不適合高頻次持鎖時間短的搶鎖場景。按照 Google 的 chubby 論文里的闡述，基于強一致協(xié)議的鎖適用于 粗粒度 的加鎖操作。這里的粗粒度指鎖占用時間較長。我們在使用時也應(yīng)思考在自己的業(yè)務(wù)場景中使用是否合適。

基于etcd

package main
import (
    "log"
    "github.com/zieckey/etcdsync"
)
func main() {
    m, err := etcdsync.New("/lock", 10, []string{"http://127.0.0.1:2379"})
    if m == nil || err != nil {
        log.Printf("etcdsync.New failed")
        return
    }
    err = m.Lock()
    if err != nil {
        log.Printf("etcdsync.Lock failed")
        return
    }
    log.Printf("etcdsync.Lock OK")
    log.Printf("Get the lock. Do something here.")
    err = m.Unlock()
    if err != nil {
        log.Printf("etcdsync.Unlock failed")
    } else {
        log.Printf("etcdsync.Unlock OK")
    }
}

etcd 中沒有像 zookeeper 那樣的 sequence 節(jié)點。所以其鎖實現(xiàn)和基于 zookeeper 實現(xiàn)的有所不同。在上述示例代碼中使用的 etcdsync 的 Lock 流程是：

先檢查 /lock 路徑下是否有值，如果有值，說明鎖已經(jīng)被別人搶了
如果沒有值，那么寫入自己的值。寫入成功返回，說明加鎖成功。寫入時如果節(jié)點被其它節(jié)點寫入過了，那么會導(dǎo)致加鎖失敗，這時候到 3
watch /lock 下的事件，此時陷入阻塞
當(dāng) /lock 路徑下發(fā)生事件時，當(dāng)前進程被喚醒。檢查發(fā)生的事件是否是刪除事件(說明鎖被持有者主動 unlock)，或者過期事件(說明鎖過期失效)。如果是的話，那么回到 1，走搶鎖流程。

redlock

package main
import (
    "fmt"
    "time"
    "github.com/garyburd/redigo/redis"
    "gopkg.in/redsync.v1"
)
func newPool(server string) *redis.Pool {
    return &redis.Pool{
        MaxIdle:     3,
        IdleTimeout: 240 * time.Second,
        Dial: func() (redis.Conn, error) {
            c, err := redis.Dial("tcp", server)
            if err != nil {
                return nil, err
            }
            return c, err
        },
        TestOnBorrow: func(c redis.Conn, t time.Time) error {
            _, err := c.Do("PING")
            return err
        },
    }
}
func newPools(servers []string) []redsync.Pool {
    pools := []redsync.Pool{}
    for _, server := range servers {
        pool := newPool(server)
        pools = append(pools, pool)
    }
    return pools
}
func main() {
    pools := newPools([]string{"127.0.0.1:6379", "127.0.0.1:6378", "127.0.0.1:6377"})
    rs := redsync.New(pools)
    m := rs.NewMutex("/lock")
    err := m.Lock()
    if err != nil {
        panic(err)
    }
    fmt.Println("lock success")
    unlockRes := m.Unlock()
    fmt.Println("unlock result: ", unlockRes)
}

redlock 也是一種阻塞鎖，單個節(jié)點操作對應(yīng)的是 set nx px 命令，超過半數(shù)節(jié)點返回成功時，就認(rèn)為加鎖成功。

關(guān)于 redlock 的設(shè)計曾經(jīng)在社區(qū)引起一場口水戰(zhàn)，分布式專家各抒己見。不過這個不是我們要討論的內(nèi)容，相關(guān)鏈接在參考資料中給出。

如何選擇

業(yè)務(wù)還在單機就可以搞定的量級時，那么按照需求使用任意的單機鎖方案就可以。

如果發(fā)展到了分布式服務(wù)階段，但業(yè)務(wù)規(guī)模不大，比如 qps < 1000，使用哪種鎖方案都差不多。如果公司內(nèi)已有可以使用的 zk/etcd/redis 集群，那么就盡量在不引入新的技術(shù)棧的情況下滿足業(yè)務(wù)需求。

業(yè)務(wù)發(fā)展到一定量級的話，就需要從多方面來考慮了。首先是你的鎖是否在任何惡劣的條件下都不允許數(shù)據(jù)丟失，如果不允許，那么就不要使用 redis 的 setnx 的簡單鎖。

如果要使用 redlock，那么要考慮你們公司 redis 的集群方案，是否可以直接把對應(yīng)的 redis 的實例的 ip+port 暴露給開發(fā)人員。如果不可以，那也沒法用。

對鎖數(shù)據(jù)的可靠性要求極高的話，那只能使用 etcd 或者 zk 這種通過一致性協(xié)議保證數(shù)據(jù)可靠性的鎖方案。但可靠的背面往往都是較低的吞吐量和較高的延遲。需要根據(jù)業(yè)務(wù)的量級對其進行壓力測試，以確保分布式鎖所使用的 etcd/zk 集群可以承受得住實際的業(yè)務(wù)請求壓力。需要注意的是，etcd 和 zk 集群是沒有辦法通過增加節(jié)點來提高其性能的。要對其進行橫向擴展，只能增加搭建多個集群來支持更多的請求。這會進一步提高對運維和監(jiān)控的要求。多個集群可能需要引入 proxy，沒有 proxy 那就需要業(yè)務(wù)去根據(jù)某個業(yè)務(wù) id 來做 sharding。如果業(yè)務(wù)已經(jīng)上線的情況下做擴展，還要考慮數(shù)據(jù)的動態(tài)遷移。這些都不是容易的事情。

在選擇具體的方案時，還是需要多加思考，對風(fēng)險早做預(yù)估。

到此這篇關(guān)于Golang分布式鎖詳細介紹的文章就介紹到這了,更多相關(guān)Go分布式鎖內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: