golang並發函數快取鎖定機制探究

高並發場景下，使用函數快取可以避免重複計算，而引入鎖定機制可保證快取資料的並發安全。 Go語言中可透過sync.Map實現緩存，並為每個緩存項目引入互斥鎖以實現並發安全性。實戰案例中，使用快取和鎖定機制有效地快取了斐波那契數列的計算結果。

Go 語言並發函數快取鎖定機制探究

前言
在高並發場景下，為了避免函數執行重複計算，可以使用快取機制。而為了確保快取資料的並發安全，則需要引入鎖定機制。本文將探討 Go 語言中函數快取鎖的實作方式，並透過實戰案例進行示範。

快取實作
實作函數緩存，最簡單的方式是使用sync.Map 類型，它提供了高效且執行緒安全的鍵值映射功能。

import "sync"

type Cache struct {
    sync.Map
}

func (c *Cache) Get(key string) (interface{}, bool) {
    return c.Load(key)
}

func (c *Cache) Set(key string, value interface{}) {
    c.Store(key, value)
}

鎖定機制
為了確保快取資料的並發安全，可以為每個快取項目引入一個互斥鎖定。

type CacheWithLock struct {
    sync.Map
    locks map[string]*sync.Mutex
}

func (c *CacheWithLock) Get(key string) (interface{}, bool) {
    c.locks[key].Lock()
    defer c.locks[key].Unlock()
    return c.Load(key)
}

func (c *CacheWithLock) Set(key string, value interface{}) {
    c.locks[key].Lock()
    defer c.locks[key].Unlock()
    c.Store(key, value)
}

實戰案例
以下是使用快取和鎖定機制的簡單範例，該範例示範如何快取斐波那契數列的計算結果。

package main

import (
    "fmt"
    "sync"
)

var cache *CacheWithLock
var fibFuncs = map[int]func(n int) int{}

func init() {
    cache = &CacheWithLock{
        Map:   make(sync.Map),
        locks: make(map[string]*sync.Mutex),
    }
    fibFuncs[0] = func(n int) int { return 0 }
    fibFuncs[1] = func(n int) int { return 1 }
}

func fib(n int) int {
    f, ok := fibFuncs[n]
    if ok {
        return f(n)
    }
    fibFuncs[n] = func(n int) int {
        return fib(n-1) + fib(n-2)
    }
    return fib(n)
}

func main() {
    for i := 0; i < 10; i++ {
        go func(n int) {
            fmt.Println(cache.Get(n))
            cache.Set(n, fib(n))
        }(i)
    }
}

運行結果

0
1
1
2
3
5
8
13
21
34

該範例中，並發 goroutine 並發計算斐波那契數列，並且正確地快取了計算結果，避免了重複計算。

以上是golang並發函數快取鎖定機制探究的詳細內容。更多資訊請關注PHP中文網其他相關文章！