实战Go：HashMap缓存的缓存数据访问缓存索引与缓存监控

在Go语言中，使用sync.Map可以实现一个简单的HashMap缓存。为了访问缓存索引和监控缓存数据，我们可以定义一些辅助函数和结构体。以下是一个示例实现：

package main

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

type CacheItem struct {
	Value      interface{}
	ExpireTime time.Time
}

type Cache struct {
	mu         sync.RWMutex
	items      map[string]CacheItem
	maxSize    int
}

func NewCache(maxSize int) *Cache {
	return &Cache{
		items:      make(map[string]CacheItem),
		maxSize:    maxSize,
	}
}

func (c *Cache) Get(key string) (interface{}, bool) {
	c.mu.RLock()
	defer c.mu.RUnlock()

	item, ok := c.items[key]
	if !ok || item.ExpireTime.Before(time.Now()) {
		return nil, false
	}

	return item.Value, true
}

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()

	if len(c.items) >= c.maxSize {
		c.evict()
	}

	c.items[key] = CacheItem{
		Value:      value,
		ExpireTime: time.Now().Add(ttl),
	}
}

func (c *Cache) evict() {
	now := time.Now()
	for key, item := range c.items {
		if item.ExpireTime.Before(now) {
			delete(c.items, key)
		}
	}
}

func (c *Cache) Monitor() {
	go func() {
		for {
			time.Sleep(10 * time.Second)
			c.mu.RLock()
			size := len(c.items)
			c.mu.RUnlock()

			fmt.Printf("Cache size: %d\n", size)
		}
	}()
}

func main() {
	cache := NewCache(10)
	cache.Set("key1", "value1", 5*time.Second)
	cache.Set("key2", "value2", 10*time.Second)

	time.Sleep(2 * time.Second)
	value, ok := cache.Get("key1")
	if ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found or expired")
	}

	cache.Monitor()

	time.Sleep(15 * time.Second)
	value, ok = cache.Get("key1")
	if ok {
		fmt.Println("key1:", value)
	} else {
		fmt.Println("key1 not found or expired")
	}
}

在这个示例中，我们定义了一个CacheItem结构体来存储缓存值和过期时间。Cache结构体包含一个sync.RWMutex用于保护缓存数据，一个map[string]CacheItem用于存储缓存数据，以及一个maxSize用于限制缓存大小。

我们实现了Get方法来获取缓存值，如果缓存不存在或已过期，则返回false。Set方法用于设置缓存值和过期时间，如果缓存已满，则会触发缓存淘汰。evict方法用于淘汰过期缓存。

此外，我们还实现了Monitor方法，用于定期输出缓存大小。在main函数中，我们创建了一个缓存实例，并演示了如何使用Get、Set和Monitor方法。