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

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

为什么要费心

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

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

• 更低的延迟：使用像sync.Map这样的内存缓存时，数据存储在应用程序的内存中。这可能导致比需要应用程序和缓存服务之间的网络通信的单独服务，如Redis，有更低的访问延迟。
• 更简单的部署：使用基于sync.Map的缓存，无需部署、配置和维护像Redis这样的额外服务。您的缓存解决方案是应用程序的一部分，使部署过程更简单，并可能减少操作复杂性。
• 减少资源使用：与像Redis这样的外部服务相比，使用sync.Map的内存缓存通常消耗更少的资源，从而节省了内存和CPU使用。这对于小规模的应用程序或资源紧张的应用程序可能更加经济高效。
• 更容易集成：在Go应用程序中直接使用sync.Map实现缓存可以更容易地与现有的代码库集成。您不需要学习新的API或管理到外部服务的连接。
• 定制性：创建自己的缓存实现时，您可以完全控制其行为和功能。您可以轻松地根据具体需求调整缓存，针对您的用例进行优化，并根据需要添加自定义过期策略或其他功能。
• 乐趣：创建实现缓存的自己的代码段会带来很多乐趣，并帮助更好地理解提供缓存功能的外部库。更好地理解它们有助于更好地利用它们提供的所有功能。

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

• 可扩展性：Redis设计用于高性能，并可以水平扩展以处理大量请求和数据大小。
• 持久性：Redis支持不同级别的数据持久性，确保您的缓存数据在重启或崩溃后仍然存在。
• 高级功能：除了简单的键值缓存外，Redis还提供了一系列功能，如数据结构、发布/订阅消息等。

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

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

为什么我们使用sync.Map

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

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

• 映射主要是读取密集型，偶尔写入。
• 键的数量随时间变化或事先不知道。
• 映射由多个goroutine并发访问。

在键的数量是固定的或事先知道的情况下，且映射可以预先分配，使用适当的同步如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应用中，以提高性能并减少对你的数据源或计算资源的负载。