+------------------+          +-----------------+
|      Cache       |          |      Item       |
+------------------+          +-----------------+
| - items: map     |1      * | - Value: interface{}
| - mu: RWMutex    |---------| - Expiration: int64
| - cleanupInterval|          +-----------------+
| - stopChan: chan |
+------------------+

       +-------------+
       |   Set操作   |
       +------+------+
              |
              v
+------+ 獲取寫鎖  +------+
|      +---------->      |
| 緩存 |          | 緩存 |
| 狀態(tài) |          | 狀態(tài) |
|      <----------+      |
+------+ 設置值后釋放鎖 +------+
              |
              v
       +-------------+
       |   Get操作   |
       +------+------+
              |
              v
+------+ 獲取讀鎖  +------+
|      +---------->      |
| 緩存 |          | 緩存 |
| 狀態(tài) |          | 狀態(tài) |
|      <----------+      |
+------+ 讀取值后釋放鎖 +------+
              |
              v
       +-------------+
       | 后臺清理任務 |
       +------+------+
              |
              v
+------+ 獲取寫鎖  +------+
|      +---------->      |
| 緩存 |          | 緩存 |
| 狀態(tài) | 刪除過期項 | 狀態(tài) |
|      <----------+      |
+------+  釋放鎖    +------+

func (c *Cache) Set(key string, value interface{}, ttl time.Duration) {
	c.mu.Lock() // 寫操作使用互斥鎖
	defer c.mu.Unlock()
	// ...
}

func (c *Cache) Get(key string) (interface{}, bool) {
	c.mu.RLock() // 讀操作使用讀鎖
	defer c.mu.RUnlock()
	// ...
}

func (c *Cache) startCleanup() {
	ticker := time.NewTicker(c.cleanupInterval)
	defer ticker.Stop()
	
	for {
		select {
		case <-ticker.C:
			c.cleanup() // 定期執(zhí)行清理
		case <-c.stopChan: // 接收停止信號
			return
		}
	}
}

func (c *Cache) cleanup() {
	c.mu.Lock()
	defer c.mu.Unlock()
	
	now := time.Now().UnixNano()
	for key, item := range c.items {
		if item.Expiration > 0 && now > item.Expiration {
			delete(c.items, key) // 刪除過期項
		}
	}
}

expiration := time.Now().Add(ttl).UnixNano()

func main() {
	// 創(chuàng)建緩存，每10秒清理一次過期項
	cache := cache.NewCache(10 * time.Second)
	defer cache.Close() // 程序退出時關閉緩存

	// 設置緩存項，5秒過期
	cache.Set("key1", "value1", 5*time.Second)
	cache.Set("key2", 42, 10*time.Second) // 整數(shù)
	cache.Set("key3", struct{}{}, 0)      // 永久有效

	// 立即獲取
	if val, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", val) // 輸出: key1: value1
	}

	// 6秒后獲取
	time.Sleep(6 * time.Second)
	if _, ok := cache.Get("key1"); !ok {
		fmt.Println("key1 expired") // 輸出: key1 expired
	}

	// 獲取永久項
	if _, ok := cache.Get("key3"); ok {
		fmt.Println("key3 still exists")
	}

	// 測試并發(fā)讀寫
	var wg sync.WaitGroup
	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			key := fmt.Sprintf("goroutine_%d", i)
			cache.Set(key, i, time.Minute)
			if val, ok := cache.Get(key); ok {
				_ = val // 使用值
			}
		}(i)
	}
	wg.Wait()
	fmt.Println("Concurrent test completed")
}

type ShardedCache struct {
	shards []*Cache
}

func NewShardedCache(shardCount int, cleanupInterval time.Duration) *ShardedCache {
	cache := &ShardedCache{
		shards: make([]*Cache, shardCount),
	}
	for i := range cache.shards {
		cache.shards[i] = NewCache(cleanupInterval)
	}
	return cache
}

func (sc *ShardedCache) getShard(key string) *Cache {
	h := fnv.New32a()
	h.Write([]byte(key))
	return sc.shards[h.Sum32()%uint32(len(sc.shards))]
}

func (c *Cache) Get(key string) (interface{}, bool) {
	c.mu.RLock()
	item, found := c.items[key]
	c.mu.RUnlock()
	
	if !found {
		return nil, false
	}
	
	// 惰性檢查過期
	if time.Now().UnixNano() > item.Expiration {
		c.mu.Lock()
		delete(c.items, key) // 過期則刪除
		c.mu.Unlock()
		return nil, false
	}
	
	return item.Value, true
}

type Cache struct {
	items map[string]Item // 直接存儲結構體而非指針
	// ...
}

type Item struct {
	Value      interface{}
	Expiration int64
}

type LRUCache struct {
	cache    map[string]*list.Element
	list     *list.List
	capacity int
	mu       sync.Mutex
}

func (l *LRUCache) Get(key string) (interface{}, bool) {
	l.mu.Lock()
	defer l.mu.Unlock()
	
	if elem, ok := l.cache[key]; ok {
		l.list.MoveToFront(elem)
		return elem.Value.(*Item).Value, true
	}
	return nil, false
}

func (l *LRUCache) Set(key string, value interface{}) {
	l.mu.Lock()
	defer l.mu.Unlock()
	
	if elem, ok := l.cache[key]; ok {
		l.list.MoveToFront(elem)
		elem.Value.(*Item).Value = value
		return
	}
	
	if len(l.cache) >= l.capacity {
		// 淘汰最久未使用
		elem := l.list.Back()
		delete(l.cache, elem.Value.(*Item).Key)
		l.list.Remove(elem)
	}
	
	elem := l.list.PushFront(&Item{Key: key, Value: value})
	l.cache[key] = elem
}