所以你需要一个小的缓存，并且不能证明 redis 或 memcached 实例是合理的。让我们看看如何在 go 中实现一个。为了好玩，我们将使用泛型来制作它，这样它就可以在我们的项目中重用。
lru 缓存通常具有固定的容量和最简单的弹出策略：弹出访问时间最长的元素。一个简单的lru缓存将实现以下接口：
type lrucache[t any] interface {
get(key string) (value t, found bool)
put(key string, value t)
keys() []string
remove(key string) bool
clear()
capacity() int
len() int
}
我们知道缓存会将数据项存储为由某个值作为键的条目。这听起来像一张地图。执行驱逐政策又如何呢？实现此目的的一种方法是为每个项目保留 timeaccessed 属性。比如：
type cacheentry[t any] struct {
data t
lastaccessed time.time
}
但是，让我们考虑一下性能，我们希望能够搜索缓存键以及插入和逐出最旧的键（如有必要），尽可能快。
使用映射（即哈希表）将为我们提供相当快的查找性能。找到最旧的条目怎么样？如果您的缓存结构如下所示：
type lrucache[t any] {
capacity int
keymap map[string]cacheentry[t]
}
当需要驱逐条目时，我们必然需要迭代地图以找到最旧的条目。
我们需要一种存储条目的方法，使我们能够有效地保持缓存条目列表的排序。最好我们不需要使用排序例程。
双链表是实现此目的的好方法，除非我们确实需要，否则我们不需要在条目中存储访问时间。因此，假设我们有一个链表，它实现了以下内容及其节点结构：
type doublelinkedlist[t any] interface {
head() *doublenode[t]
tail() *doublenode[t]
// append inserts new item at tail
append(data t) *doublenode[t]
// push appends new item at head
push(data t) *doublenode[t]
remove(node *doublenode[t]) *doublenode[t]
removetail() *doublenode[t]
movetohead(node *doublenode[t])
}
type doublenode[t any] struct {
data t
prev *doublenode[t]
next *doublenode[t]
}
缓存结构现在看起来像这样：
type lrucache[t any] struct {
capacity int
keymap map[string]*doublenode[lrucacheentry[t]]
list doublelinkedlist[lrucacheentry[t]]
}
缓存条目结构将是：
type lrucacheentry[t any] struct {
key string
value t
}
实际上，您可能会使用缓存键的接口。我使用字符串来保持代码简单。
在这里的实现中，缓存中最近访问的条目将位于头部，最近最少使用的条目将位于尾部。所以，当需要驱逐时，我们只需删除链表的尾部元素即可。
实现 get() 函数很简单：
func (l *lrucache[t]) get(key string) (value t, found bool) {
if node, ok := l.keymap[key]; ok {
l.list.movetohead(node)
return node.data.value, ok
}
var zero t
return zero, false
}
get 只需检索键的映射条目，然后将节点移动到列表的头部，因为它现在是“最近使用的”。
Metafox 是一个企业内容管理系统，使用一个特别的模板系统，你可通过一些特定的设计和代码来轻松创建 Web 网站，内容存储在 SQL 关系数据库，通过 Web 进行管理，简单、快速而且高效。 Metafox 0.9.1 发布，该版本改用一种更棒的 URL 风格，实现了 RSS 源（可包含远端网站内容到 Metafox 段中），重定向老的访问密钥到新的密钥，增加 RotateAntispam 技
put() 函数是我们在必要时处理驱逐的地方：
func (l *lrucache[t]) put(key string, value t) {
if node, ok := l.keymap[key]; ok {
node.data = lrucacheentry[t]{
key: key,
value: value,
}
// move the element to the most recent position
l.list.movetohead(node)
} else {
// insert the new element at the head
newnode := l.list.push(lrucacheentry[t]{
key: key,
value: value,
})
l.keymap[key] = newnode
}
// is eviction necessary
if len(l.keymap) > l.capacity {
noderemoved := l.list.removetail()
delete(l.keymap, noderemoved.data.key)
}
}
对于 put()，我们首先检查给定键是否已经有值。如果是，则更新该值并将该节点移动到链表的头部。否则，我们创建一个新的缓存条目，将其作为头添加到列表中，并将其添加到我们的映射中。
最后，不要忘记检查容量。如果新条目超出了容量，我们将驱逐最旧的条目（即列表的尾部）并从映射中删除该条目。
请注意，将密钥存储为缓存条目的一部分允许我们快速从映射中删除密钥。如果我们只将数据存储在缓存条目中，那么我们需要迭代映射才能找到它。
此缓存缺少对于多线程应用程序来说至关重要的东西。没有同步。实际上，缓存将由多个线程访问。同步是一个复杂的话题。对于我们的实现，我们可以向缓存结构添加互斥锁：
type lrucache[t any] struct {
capacity int
keymap map[string]doublenode[lrucacheentry[t]]
list doublelinkedlist[lrucacheentry[t]]
mutex sync.rwmutex
}
然后在每个函数的开头添加以下内容。
l.mutex.lock()
defer l.mutex.unlock()
请注意，我们正在使用读/写锁。有些函数不会改变缓存的结构，所以我们可以使用提供的读锁方法，例如len()函数：
func (l *lruCache[T]) Len() int {
l.mutex.RLock()
defer l.mutex.RUnlock()
return len(l.keyMap)
}
注意，如果有大量线程尝试访问缓存，这里选择的同步策略可能会崩溃。这是一个复杂的主题，本身可能是一系列帖子。
请参阅下面链接中给出的存储库中的完整实现。
您会采取哪些不同的措施来实现缓存？您将如何解决同步问题？我很想听听您对此的想法。对此没有单一的解决方案，因此请在下面发表您的评论。
谢谢！
这篇文章以及本系列所有文章的代码可以在这里找到
