初学者指南：如何在golang中实现缓存？

package main

import (
    "fmt"
    "time"
)

// Cache stores previously computed results.
var Cache = map[string]interface{}{}

func ExampleCache() {
    // Check if the key is in the cache.
    value, ok := Cache["mykey"]
    if ok {
        fmt.Println("From Cache:", value)
        return
    }

    // Compute the result if it's not in the cache.
    time.Sleep(2 * time.Second)
    result := "Hello, World!"

    // Store the result in the cache.
    Cache["mykey"] = result

    fmt.Println("Computed Result:", result)
}

func main() {
    ExampleCache()
    ExampleCache()
}

package main

import (
    "fmt"
    "sync"
    "time"
)

// ExpirationMap stores keys and expirations.
type ExpirationMap struct {
    sync.RWMutex
    data map[string]time.Time
}

// Expired returns true if key has expired.
func (m *ExpirationMap) Expired(key string) bool {
    m.RLock()
    defer m.RUnlock()

    // Get the key's expiration time.
    expiration, ok := m.data[key]
    if !ok {
        return true
    }

    // Check if the key has expired.
    return time.Until(expiration) < 0
}

// Set sets the key's expiration time.
func (m *ExpirationMap) Set(key string, duration time.Duration) {
    m.Lock()
    defer m.Unlock()

    // Set the key's expiration time.
    m.data[key] = time.Now().Add(duration)
}

// Delete removes the key from the map.
func (m *ExpirationMap) Delete(key string) {
    m.Lock()
    defer m.Unlock()

    // Delete the key from the map.
    delete(m.data, key)
}

// Cache stores previously computed results.
var Cache = map[string]interface{}{}

// Expiration stores expiration times for cache keys.
var Expiration = ExpirationMap{data: make(map[string]time.Time)}

func ExampleCacheWithExpiration() {
    // Check if the key is in the cache.
    value, ok := Cache["mykey"]
    if ok && !Expiration.Expired("mykey") {
        fmt.Println("From Cache:", value)
        return
    }

    // Compute the result if it's not in the cache.
    time.Sleep(2 * time.Second)
    result := "Hello, World!"

    // Store the result in the cache.
    Cache["mykey"] = result
    Expiration.Set("mykey", 5*time.Second)

    fmt.Println("Computed Result:", result)
}

func main() {
    ExampleCacheWithExpiration()
    ExampleCacheWithExpiration()

    // Wait for the expiration time to elapse.
    time.Sleep(6 * time.Second)

    ExampleCacheWithExpiration()
}