在 Golang 中实现高效缓存机制的指南？-Golang-PHP中文网

在 Golang 中实现高效缓存机制的指南？

王林

发布： 2024-07-06 18:48:01

原创

948人浏览过

在 golang 中实现高效缓存机制的方法有：lru 缓存：使用容器包的 lru 缓存实现，跟踪最不经常使用的条目并将其删除，为最近使用的条目腾出空间。并发安全缓存：使用 sync 包的原语实现，通过读写锁保证在并发环境中安全访问缓存。

在 Golang 中实现高效缓存机制的指南？

在 GoLang 中实现高效缓存机制的指南

缓存是一种计算机技术，用于在内存中存储经常访问的数据，以便可以快速检索，而无需从更慢的存储介质（例如硬盘）中重新加载。在 GoLang 中，有几种方法可以实现缓存。

LRU 缓存

立即学习“go语言免费学习笔记（深入）”；

LRU（最近最少使用）缓存是一种缓存，它会跟踪最不经常使用的条目并将其删除以腾出空间给最近使用的条目。GoLang 的容器包中提供了 LRU 缓存的实现：

面试猫

AI面试助手，在线面试神器，助你轻松拿Offer

352

查看详情

package main

import (
    "container/list"
    "fmt"
)

type LRUCache struct {
    size int
    cache map[interface{}]interface{}
    order *list.List
}

func NewLRUCache(size int) *LRUCache {
    return &LRUCache{
        size:  size,
        cache: make(map[interface{}]interface{}),
        order: list.New(),
    }
}

func (c *LRUCache) Get(key interface{}) (interface{}, bool) {
    val, ok := c.cache[key]
    if !ok {
        return nil, false
    }

    c.order.Remove(val)
    c.order.PushFront(val)
    return val, true
}

func (c *LRUCache) Set(key, value interface{}) {
    if c.size == 0 {
        return
    }

    if _, ok := c.cache[key]; ok {
        c.order.Remove(c.cache[key])
    } else if c.order.Len() >= c.size {
        val := c.order.Back()
        delete(c.cache, val.Value)
        c.order.Remove(val)
    }

    c.cache[key] = value
    c.order.PushFront(value)
}

func main() {
    cache := NewLRUCache(3)
    cache.Set(1, "a")
    cache.Set(2, "b")
    cache.Set(3, "c")

    fmt.Println(cache.Get(1))  // (a, true)
    fmt.Println(cache.Get(2))  // (b, true)
    fmt.Println(cache.Get(4))  // (nil, false)
    cache.Set(4, "d")
    fmt.Println(cache.Get(3))  // (nil, false)
    fmt.Println(cache.Get(4))  // (d, true)
}

登录后复制

并发安全缓存

并发安全缓存是可以在安全地并发访问的环境中使用的缓存。sync 包提供了几个用于实现并发安全性的原语：

package main

import (
    "sync"
    "fmt"
)

type ConcurrentCache struct {
    sync.RWMutex
    cache map[interface{}]interface{}
}

func NewConcurrentCache() *ConcurrentCache {
    return &ConcurrentCache{
        cache: make(map[interface{}]interface{}),
    }
}

func (c *ConcurrentCache) Get(key interface{}) (interface{}, bool) {
    c.RLock()
    defer c.RUnlock()
    val, ok := c.cache[key]
    return val, ok
}

func (c *ConcurrentCache) Set(key, value interface{}) {
    c.Lock()
    defer c.Unlock()
    c.cache[key] = value
}

func main() {
    cache := NewConcurrentCache()
    cache.Set(1, "a")
    fmt.Println(cache.Get(1))  // (a, true)

    // 并发访问
    go cache.Set(2, "b")
    fmt.Println(cache.Get(2))  // (b, true)
}

登录后复制

实用案例

缓存可以在各种应用程序中使用，例如：