<返回更多

Go中使用sync.Map实现线程安全的缓存

2023-10-24  微信公众号  技术的游戏
加入收藏

缓存是优化现代应用程序性能的关键方面。它允许您存储并快速检索昂贵操作的结果或经常访问的数据,减少了反复重新计算或获取数据的需要。在本文中,我们将探讨如何使用sync.Map包在Go中实现线程安全的缓存。这种缓存实现支持缓存条目的过期,确保过时的数据不会滞留在缓存中。

Go中使用sync.Map实现线程安全的缓存

为什么要费心

在我们开始实现自己的线程安全内存缓存之前,让我们考虑一下其优缺点。考虑到替代方案是使用为缓存而发明的、有长期使用和支持历史的外部库(工具),让我们思考一下优点和缺点。

使用Go的sync.Map实现自己的线程安全缓存相比使用像redis这样的外部库有几个优点,这取决于您的用例和要求。以下是使用sync.Map创建自己的缓存可能有优势的一些原因:

但是,值得注意的是,使用像Redis这样的外部缓存解决方案对于较大规模的应用程序或那些有更复杂的缓存需求的应用程序有其自身的一系列优势。使用Redis的一些好处包括:

最终,选择使用sync.Map实现自己的缓存还是使用像Redis这样的外部库将取决于您的具体需求、应用程序的规模以及您在性能、复杂性和资源方面愿意做的权衡。

此外,实现您的缓存会带来乐趣并帮助更好地理解像Redis这样的更复杂的产品。因此,我们将在此文章中实现一个。

为什么我们使用sync.Map

简单地说,因为它完美地满足了我们的需要。更深入的解释 - sync.Map是Go标准库中的一个并发的、线程安全的map实现。它设计用于在多个goroutine并发访问映射的情况下使用,并且键的数量是未知的或随时间变化的。

值得注意的是,虽然sync.Map是特定用例的一个很好的选择,但它并不意味着要替换所有场景的内置map类型。特别是,sync.Map最适合以下情况:

在键的数量是固定的或事先知道的情况下,且映射可以预先分配,使用适当的同步如sync.Mutex或sync.RWMutex的内置map类型可能会提供更好的性能。

创建SafeCache

如上所述,我们的SafeCache是一个简单的、线程安全的缓存,使用Go的sync.Map存储其键值对。

首先,我们定义一个CacheEntry结构来保存值及其过期时间戳:

type CacheEntry struct {
    value      interface{}
    expiration int64
}

在SafeCache结构中嵌入了一个sync.Map,它提供了对键值对的并发安全访问:

type SafeCache struct {
    syncMap sync.Map
}

向缓存中添加值

然后我们定义了一个 Set 方法,该方法允许我们在缓存中存储一个带有指定生存时间(TTL,Time To Live)的值。TTL 决定了缓存条目应被认为有效的时间长度。一旦 TTL 过期,在下一个清理周期中将会移除该缓存条目。

func (sc *SafeCache) Set(key string, value interface{}, ttl time.Duration) {
    expiration := time.Now().Add(ttl).UnixNano()
    sc.syncMap.Store(key, CacheEntry{value: value, expiration: expiration})
}

从缓存中检索值

接下来需要的方法是 Get,它使用键从缓存中检索值。如果没有找到该值或该值已过期,该方法将返回 false:

func (sc *SafeCache) Get(key string) (interface{}, bool) {
    // ... (see the provided code for the full implementation)
}

在 Get 方法中重要的是从缓存加载值后进行类型断言。我们依赖于 sync.Map 的 Load 方法,该方法返回接口。

entry, found := sc.syncMap.Load(key)
 if !found {
  return nil, false
 }
 // Type assertion to CacheEntry, as entry is an interface{}
 cacheEntry := entry.(CacheEntry)

从缓存中移除值

当然,我们还需要一个 Delete 方法,使我们能够从缓存中移除一个值:

func (sc *SafeCache) Delete(key string) {
    sc.syncMap.Delete(key)
}

清理过期条目

我们通过 CleanUp 方法扩展了缓存,该方法负责定期从缓存中删除过期的条目。它使用 sync.Map 提供的 Range 方法遍历缓存中的所有键值对,并删除那些TTL已过期的条目:

func (sc *SafeCache) CleanUp() {
    // ... (see the provided code for the full implementation)
}

要运行 CleanUp 方法,我们可以在初始化缓存时启动一个单独的 Goroutine:

cache := &SafeCache{}
go cache.CleanUp()

完整的代码片段

package cache

import (
 "sync"
 "time"
)

// CacheEntry is a value stored in the cache.
type CacheEntry struct {
 value      interface{}
 expiration int64
}

// SafeCache is a thread-safe cache.
type SafeCache struct {
 syncMap sync.Map
}

// Set stores a value in the cache with a given TTL
// (time to live) in seconds.
func (sc *SafeCache) Set(key string, value interface{}, ttl time.Duration) {
 expiration := time.Now().Add(ttl).UnixNano()
 sc.syncMap.Store(key, CacheEntry{value: value, expiration: expiration})
}

// Get retrieves a value from the cache. If the value is not found
// or has expired, it returns false.
func (sc *SafeCache) Get(key string) (interface{}, bool) {
 entry, found := sc.syncMap.Load(key)
 if !found {
  return nil, false
 }
 // Type assertion to CacheEntry, as entry is an interface{}
 cacheEntry := entry.(CacheEntry)
 if time.Now().UnixNano() > cacheEntry.expiration {
  sc.syncMap.Delete(key)
  return nil, false
 }
 return cacheEntry.value, true
}

// Delete removes a value from the cache.
func (sc *SafeCache) Delete(key string) {
 sc.syncMap.Delete(key)
}

// CleanUp periodically removes expired entries from the cache.
func (sc *SafeCache) CleanUp() {
 for {
  time.Sleep(1 * time.Minute)
  sc.syncMap.Range(func(key, entry interface{}) bool {
   cacheEntry := entry.(CacheEntry)
   if time.Now().UnixNano() > cacheEntry.expiration {
    sc.syncMap.Delete(key)
   }
   return true
  })
 }
}

最后,你可以运行以下的 mAIn.go 程序来检查缓存是否工作。我们创建了一个HTTP服务器,它在“/compute”端点监听请求。该服务器接受一个整数n作为查询参数,并返回昂贵计算的结果(在这种情况下,带有模拟延迟的简单平方操作)。服务器首先检查缓存,看看给定输入的结果是否已经被缓存;如果没有,它会计算结果,将其存储在缓存中,并将其返回给客户端。

要测试服务器,运行代码并请求http://localhost:8080/compute?n=5。第一个请求会花费更长的时间(由于模拟的延迟),但具有相同n的后续请求将立即返回缓存的结果。

package main

import (
 "fmt"
 "log"
 ".NET/http"
 "safe-cache/cache"
 "strconv"
 "time"
)


func expensiveComputation(n int) int {
 // Simulate an expensive computation
 time.Sleep(2 * time.Second)
 return n * n
}

func main() {
 safeCache := &cache.SafeCache{}
 // Start a goroutine to periodically clean up the cache
 go safeCache.CleanUp()

 http.HandleFunc("/compute", func(w http.ResponseWriter, r *http.Request) {
  query := r.URL.Query()
  n, err := strconv.Atoi(query.Get("n"))
  if err != nil {
   http.Error(w, "Invalid input", http.StatusBadRequest)
   return
  }

  cacheKey := fmt.Sprintf("result_%d", n)
  cachedResult, found := safeCache.Get(cacheKey)
  var result int
  if found {
   result = cachedResult.(int)
  } else {
   result = expensiveComputation(n)
   safeCache.Set(cacheKey, result, 1*time.Minute)
  }

  _, err = fmt.Fprintf(w, "Result: %dn", result)
  if err != nil {
   return
  }
 })

 log.Fatal(http.ListenAndServe(":8080", nil))
}

结论

在本文中,我们展示了如何使用sync.Map包在Go中实现一个简单、线程安全的缓存。

这个缓存实现支持基于TTL的过期的键值存储,并可以轻松地集成到你的Go应用中,以提高性能并减少对你的数据源或计算资源的负载。

关键词:Go      点击(19)
声明:本站部分内容来自互联网,如有版权侵犯或其他问题请与我们联系,我们将立即删除或处理。
▍相关推荐
更多Go相关>>>