更新版本到2.0

dns/cache.go

@@ -1,6 +1,10 @@
 package dns
 
 import (
+	"encoding/json"
+	"io/ioutil"
+	"math"
+	"os"
 	"sync"
 	"time"
 
@@ -9,148 +13,406 @@ import (
 
 // DNSCacheItem 表示缓存中的DNS响应项
 type DNSCacheItem struct {
-	Response *dns.Msg  // DNS响应消息
-	Expiry   time.Time // 过期时间
-	HasDNSSEC bool     // 是否包含DNSSEC记录
+	Response  *dns.Msg  // DNS响应消息
+	Expiry    time.Time // 过期时间
+	HasDNSSEC bool      // 是否包含DNSSEC记录
+	Size      int       // 缓存项大小（字节）
+}
+
+// SerializableDNSCacheItem 用于JSON序列化的缓存项结构
+type SerializableDNSCacheItem struct {
+	ResponseBytes []byte `json:"responseBytes"` // 二进制DNS响应
+	Expiry        int64  `json:"expiry"`        // 过期时间（纳秒）
+	HasDNSSEC     bool   `json:"hasDNSSEC"`     // 是否包含DNSSEC记录
+	Size          int    `json:"size"`          // 缓存项大小（字节）
+}
+
+// SerializableDNSCache 可序列化的缓存结构
+type SerializableDNSCache struct {
+	Items         map[string]*SerializableDNSCacheItem `json:"items"`         // 缓存项
+	TTL           int64                                `json:"ttl"`           // 默认TTL（纳秒）
+	MaxSize       int                                  `json:"maxSize"`       // 最大缓存大小
+	CacheMode     string                               `json:"cacheMode"`     // 缓存模式
+	CacheFilePath string                               `json:"cacheFilePath"` // 缓存文件路径
 }
 
 // DNSCache DNS缓存结构
 type DNSCache struct {
-	cache      map[string]*DNSCacheItem // 缓存映射表
-	mutex      sync.RWMutex             // 读写锁，保护缓存
-	defaultTTL time.Duration            // 默认缓存TTL
+	cache         map[string]*LRUNode // 缓存映射表，直接存储链表节点
+	mutex         sync.RWMutex        // 读写锁，保护缓存
+	ttl           time.Duration       // 默认缓存TTL
+	maxSize       int                 // 最大缓存条目数
+	cacheSize     int64               // 当前缓存大小（字节）
+	maxCacheSize  int64               // 最大缓存大小（字节）
+	cacheMode     string              // 缓存模式
+	cacheFilePath string              // 缓存文件路径
+	saveInterval  time.Duration       // 保存间隔
+	saveMutex     sync.Mutex          // 保存互斥锁
+	maxCacheTTL   time.Duration       // 最大缓存TTL
+	minCacheTTL   time.Duration       // 最小缓存TTL
+	saveStopCh    chan struct{}       // 保存循环停止通道
+	saveRunning   bool                // 保存循环是否运行
+	saveLoopMutex sync.Mutex          // 保护保存循环状态的互斥锁
+	// 双向链表头和尾指针，用于LRU淘汰
+	head *LRUNode // 头指针，指向最久未使用的节点
+	tail *LRUNode // 尾指针，指向最近使用的节点
+	// 缓存变化跟踪，用于智能保存
+	changeCount       int           // 缓存变化次数
+	lastSaveCacheSize int64         // 上次保存时的缓存大小
+	lastSaveItemCount int           // 上次保存时的缓存项数量
+	lastSaveTime      time.Time     // 上次保存时间
+	minSaveInterval   time.Duration // 最小保存间隔，避免过于频繁的保存
+}
+
+// LRUNode 双向链表节点，用于LRU缓存
+type LRUNode struct {
+	key   string
+	value *DNSCacheItem
+	prev  *LRUNode
+	next  *LRUNode
 }
 
 // NewDNSCache 创建新的DNS缓存实例
-func NewDNSCache(defaultTTL time.Duration) *DNSCache {
+func NewDNSCache(defaultTTL time.Duration, cacheMode string, cacheSizeMB int, cacheFilePath string, saveInterval time.Duration, maxCacheTTL, minCacheTTL time.Duration) *DNSCache {
+	// 计算最大缓存大小（字节）
+	maxCacheSize := int64(cacheSizeMB) * 1024 * 1024
+
 	cache := &DNSCache{
-		cache:      make(map[string]*DNSCacheItem),
-		defaultTTL: defaultTTL,
+		cache:             make(map[string]*LRUNode),
+		ttl:               defaultTTL,
+		maxSize:           10000, // 默认最大缓存10000条记录
+		cacheSize:         0,
+		maxCacheSize:      maxCacheSize,
+		cacheMode:         cacheMode,
+		cacheFilePath:     cacheFilePath,
+		saveInterval:      saveInterval,
+		maxCacheTTL:       maxCacheTTL,
+		minCacheTTL:       minCacheTTL,
+		saveStopCh:        make(chan struct{}),
+		saveRunning:       false,
+		head:              nil,
+		tail:              nil,
+		changeCount:       0,
+		lastSaveCacheSize: 0,
+		lastSaveItemCount: 0,
+		lastSaveTime:      time.Now(),
+		minSaveInterval:   30 * time.Second, // 最小保存间隔为30秒，避免过于频繁的保存
+	}
+
+	// 加载现有缓存（如果存在）
+	if cacheMode == "file" {
+		cache.LoadFromFile()
 	}
 
 	// 启动缓存清理协程
 	go cache.startCleanupLoop()
 
+	// 启动定期保存协程（如果是文件缓存）
+	if cacheMode == "file" {
+		go cache.startSaveLoop()
+	}
+
 	return cache
 }
 
+// addNodeToTail 将节点添加到链表尾部（表示最近使用）
+func (c *DNSCache) addNodeToTail(node *LRUNode) {
+	if c.tail == nil {
+		// 链表为空
+		c.head = node
+		c.tail = node
+	} else {
+		// 添加到尾部
+		node.prev = c.tail
+		c.tail.next = node
+		c.tail = node
+	}
+}
+
+// removeNode 从链表中移除指定节点
+func (c *DNSCache) removeNode(node *LRUNode) {
+	if node.prev != nil {
+		node.prev.next = node.next
+	} else {
+		// 移除的是头节点
+		c.head = node.next
+	}
+
+	if node.next != nil {
+		node.next.prev = node.prev
+	} else {
+		// 移除的是尾节点
+		c.tail = node.prev
+	}
+
+	// 清空节点的前后指针
+	node.prev = nil
+	node.next = nil
+}
+
+// moveNodeToTail 将节点移动到链表尾部（表示最近使用）
+func (c *DNSCache) moveNodeToTail(node *LRUNode) {
+	// 如果已经是尾节点，不需要移动
+	if node == c.tail {
+		return
+	}
+
+	// 从链表中移除节点
+	c.removeNode(node)
+	// 重新添加到尾部
+	c.addNodeToTail(node)
+}
+
 // cacheKey 生成缓存键
 func cacheKey(qName string, qType uint16) string {
 	return qName + "|" + dns.TypeToString[qType]
 }
 
+// calculateItemSize 计算缓存项大小
+func calculateItemSize(item *DNSCacheItem) int {
+	// 使用更高效的方式估算缓存项大小
+	// 避免使用json.Marshal和rr.String()，因为它们在高频调用时会消耗大量CPU资源
+	size := 0
+
+	// 估算Response大小
+	if item.Response != nil {
+		// 粗略估算DNS消息大小
+		// 头部大小约12字节
+		size += 12
+
+		// 问题部分
+		for _, q := range item.Response.Question {
+			size += len(q.Name) + 4 // 域名长度 + 类型(2) + 类(2)
+		}
+
+		// 高效估算资源记录大小，避免调用rr.String()
+		estimateRRSize := func(rr dns.RR) int {
+			rrSize := len(rr.Header().Name) + 10 // 域名 + 类型(2) + 类(2) + TTL(4) + 长度(2)
+
+			switch rr.Header().Rrtype {
+			case dns.TypeA:
+				rrSize += 4 // IPv4地址
+			case dns.TypeAAAA:
+				rrSize += 16 // IPv6地址
+			case dns.TypeCNAME, dns.TypePTR, dns.TypeNS:
+				// 对于CNAME、PTR、NS记录，需要估算目标域名长度
+				if cname, ok := rr.(*dns.CNAME); ok {
+					rrSize += len(cname.Target)
+				} else if ptr, ok := rr.(*dns.PTR); ok {
+					rrSize += len(ptr.Ptr)
+				} else if ns, ok := rr.(*dns.NS); ok {
+					rrSize += len(ns.Ns)
+				} else {
+					// 默认估算
+					rrSize += 30
+				}
+			case dns.TypeMX:
+				// MX记录：优先级(2) + 目标域名
+				rrSize += 2 + 30 // 默认30字节目标域名
+			case dns.TypeTXT:
+				// TXT记录：文本长度
+				rrSize += 50 // 默认50字节文本
+			case dns.TypeSRV:
+				// SRV记录：优先级(2) + 权重(2) + 端口(2) + 目标域名
+				rrSize += 6 + 30 // 默认30字节目标域名
+			case dns.TypeSOA:
+				// SOA记录：主NS + 管理员邮箱 + 序列号(4) + 刷新时间(4) + 重试时间(4) + 过期时间(4) + 最小TTL(4)
+				rrSize += 100 // 默认100字节
+			default:
+				// 其他类型记录，使用默认估算
+				rrSize += 50
+			}
+
+			return rrSize
+		}
+
+		// 回答部分
+		for _, rr := range item.Response.Answer {
+			size += estimateRRSize(rr)
+		}
+
+		// 授权部分
+		for _, rr := range item.Response.Ns {
+			size += estimateRRSize(rr)
+		}
+
+		// 附加部分
+		for _, rr := range item.Response.Extra {
+			if rr.Header().Rrtype == dns.TypeOPT {
+				// OPT记录大小约为40字节（EDNS0）
+				size += 40
+			} else {
+				size += estimateRRSize(rr)
+			}
+		}
+	}
+
+	// 其他字段大小
+	size += 8 // Expiry
+	size += 1 // HasDNSSEC
+
+	return size
+}
+
 // hasDNSSECRecords 检查响应是否包含DNSSEC记录
 func hasDNSSECRecords(response *dns.Msg) bool {
-	// 检查响应中是否包含DNSSEC相关记录（DNSKEY、RRSIG、DS、NSEC、NSEC3等）
+	// 直接在循环中检查RR类型，避免创建匿名函数的开销
+
+	// 检查回答部分
 	for _, rr := range response.Answer {
-		if _, ok := rr.(*dns.DNSKEY); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.RRSIG); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.DS); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.NSEC); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.NSEC3); ok {
+		switch rr.(type) {
+		case *dns.DNSKEY, *dns.RRSIG, *dns.DS, *dns.NSEC, *dns.NSEC3:
 			return true
 		}
 	}
+
+	// 检查授权部分
 	for _, rr := range response.Ns {
-		if _, ok := rr.(*dns.DNSKEY); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.RRSIG); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.DS); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.NSEC); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.NSEC3); ok {
+		switch rr.(type) {
+		case *dns.DNSKEY, *dns.RRSIG, *dns.DS, *dns.NSEC, *dns.NSEC3:
 			return true
 		}
 	}
+
+	// 检查附加部分
 	for _, rr := range response.Extra {
-		if _, ok := rr.(*dns.DNSKEY); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.RRSIG); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.DS); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.NSEC); ok {
-			return true
-		}
-		if _, ok := rr.(*dns.NSEC3); ok {
+		switch rr.(type) {
+		case *dns.DNSKEY, *dns.RRSIG, *dns.DS, *dns.NSEC, *dns.NSEC3:
 			return true
 		}
 	}
+
 	return false
 }
 
 // Set 设置缓存项
 func (c *DNSCache) Set(qName string, qType uint16, response *dns.Msg, ttl time.Duration) {
+	// 设置默认TTL
 	if ttl <= 0 {
-		ttl = c.defaultTTL
+		ttl = c.ttl
+	}
+
+	// 应用maxCacheTTL和minCacheTTL约束
+	if c.maxCacheTTL > 0 && ttl > c.maxCacheTTL {
+		ttl = c.maxCacheTTL
+	}
+	if c.minCacheTTL > 0 && ttl < c.minCacheTTL {
+		ttl = c.minCacheTTL
 	}
 
 	key := cacheKey(qName, qType)
 	item := &DNSCacheItem{
-		Response: response.Copy(), // 复制响应以避免外部修改
-		Expiry:   time.Now().Add(ttl),
+		Response:  response.Copy(), // 复制响应以避免外部修改
+		Expiry:    time.Now().Add(ttl),
 		HasDNSSEC: hasDNSSECRecords(response), // 检查并设置DNSSEC标志
 	}
 
+	// 计算缓存项大小
+	item.Size = calculateItemSize(item)
+
 	c.mutex.Lock()
-	c.cache[key] = item
-	c.mutex.Unlock()
+	defer c.mutex.Unlock()
+
+	// 如果条目已存在，先从链表和缓存中移除，并更新缓存大小
+	if existingNode, found := c.cache[key]; found {
+		c.cacheSize -= int64(existingNode.value.Size)
+		c.removeNode(existingNode)
+		delete(c.cache, key)
+	}
+
+	// 创建新的链表节点并添加到尾部
+	newNode := &LRUNode{
+		key:   key,
+		value: item,
+	}
+	c.addNodeToTail(newNode)
+	c.cache[key] = newNode
+	c.cacheSize += int64(item.Size)
+
+	// 检查是否超过最大条目数限制，如果超过则移除最久未使用的条目
+	if len(c.cache) > c.maxSize {
+		// 最久未使用的条目是链表的头节点
+		if c.head != nil {
+			c.cacheSize -= int64(c.head.value.Size)
+			oldestKey := c.head.key
+			// 从缓存和链表中移除头节点
+			delete(c.cache, oldestKey)
+			c.removeNode(c.head)
+		}
+	}
+
+	// 检查是否超过最大缓存大小，如果超过则继续移除最久未使用的条目
+	for c.cacheSize > c.maxCacheSize && c.head != nil {
+		c.cacheSize -= int64(c.head.value.Size)
+		oldestKey := c.head.key
+		delete(c.cache, oldestKey)
+		c.removeNode(c.head)
+	}
+
+	// 更新缓存变化计数
+	c.changeCount++
 }
 
 // Get 获取缓存项
 func (c *DNSCache) Get(qName string, qType uint16) (*dns.Msg, bool) {
 	key := cacheKey(qName, qType)
 
+	// 首先使用读锁检查缓存项是否存在和是否过期
 	c.mutex.RLock()
-	item, found := c.cache[key]
+	node, found := c.cache[key]
 	if !found {
 		c.mutex.RUnlock()
 		return nil, false
 	}
 
 	// 检查是否过期
-	if time.Now().After(item.Expiry) {
+	if time.Now().After(node.value.Expiry) {
 		c.mutex.RUnlock()
-		// 过期了，删除缓存项（在写锁中）
-		c.delete(key)
+		// 需要删除过期条目，使用写锁
+		c.mutex.Lock()
+		// 再次检查，防止在读写锁切换期间被其他协程处理
+		if node, stillExists := c.cache[key]; stillExists && time.Now().After(node.value.Expiry) {
+			delete(c.cache, key)
+			c.removeNode(node)
+		}
+		c.mutex.Unlock()
 		return nil, false
 	}
 
-	// 返回缓存的响应副本
-	response := item.Response.Copy()
+	// 返回前释放读锁，避免长时间持有锁
+	response := node.value.Response.Copy()
 	c.mutex.RUnlock()
 
+	// 标记为最近使用需要修改链表，使用写锁
+	c.mutex.Lock()
+	// 再次检查节点是否存在，防止在读写锁切换期间被删除
+	if node, stillExists := c.cache[key]; stillExists {
+		c.moveNodeToTail(node)
+	}
+	c.mutex.Unlock()
+
 	return response, true
 }
 
 // delete 删除缓存项
 func (c *DNSCache) delete(key string) {
 	c.mutex.Lock()
-	delete(c.cache, key)
-	c.mutex.Unlock()
+	defer c.mutex.Unlock()
+
+	// 从缓存和链表中删除
+	if node, found := c.cache[key]; found {
+		delete(c.cache, key)
+		c.removeNode(node)
+	}
 }
 
 // Clear 清空缓存
 func (c *DNSCache) Clear() {
 	c.mutex.Lock()
-	c.cache = make(map[string]*DNSCacheItem)
+	c.cache = make(map[string]*LRUNode)
+	// 重置链表指针
+	c.head = nil
+	c.tail = nil
 	c.mutex.Unlock()
 }
 
@@ -163,24 +425,414 @@ func (c *DNSCache) Size() int {
 
 // startCleanupLoop 启动定期清理过期缓存的协程
 func (c *DNSCache) startCleanupLoop() {
-	ticker := time.NewTicker(time.Minute * 5) // 每5分钟清理一次
+	// 初始清理间隔为1分钟
+	cleanupInterval := time.Minute * 1
+	ticker := time.NewTicker(cleanupInterval)
 	defer ticker.Stop()
 
 	for range ticker.C {
-		c.cleanupExpired()
+		cleanupInterval = c.cleanupExpired()
+
+		// 调整下次清理间隔，范围：15秒到5分钟
+		if cleanupInterval < 15*time.Second {
+			cleanupInterval = 15 * time.Second
+		} else if cleanupInterval > 5*time.Minute {
+			cleanupInterval = 5 * time.Minute
+		}
+
+		// 更新清理间隔
+		ticker.Reset(cleanupInterval)
 	}
 }
 
-// cleanupExpired 清理过期的缓存项
-func (c *DNSCache) cleanupExpired() {
+// startSaveLoop 启动定期保存缓存的协程
+func (c *DNSCache) startSaveLoop() {
+	c.saveLoopMutex.Lock()
+	// 如果已经在运行，直接返回
+	if c.saveRunning {
+		c.saveLoopMutex.Unlock()
+		return
+	}
+	// 重置停止通道
+	c.saveStopCh = make(chan struct{})
+	c.saveRunning = true
+	c.saveLoopMutex.Unlock()
+
+	go func() {
+		ticker := time.NewTicker(c.saveInterval) // 根据配置的间隔保存
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				// 检查缓存模式，如果不是file模式则不保存
+				c.mutex.RLock()
+				mode := c.cacheMode
+				c.mutex.RUnlock()
+				if mode == "file" {
+					c.SaveToFile()
+				}
+			case <-c.saveStopCh:
+				// 停止保存循环
+				c.saveLoopMutex.Lock()
+				c.saveRunning = false
+				c.saveLoopMutex.Unlock()
+				return
+			}
+		}
+	}()
+}
+
+// saveCacheToFile 保存缓存到文件的底层实现，不检查缓存模式
+func (c *DNSCache) saveCacheToFile() {
+	c.saveMutex.Lock()
+	defer c.saveMutex.Unlock()
+
+	// 智能保存策略
+	// 1. 如果缓存变化次数少于10次，跳过保存
+	// 2. 如果距离上次保存时间不足最小保存间隔，跳过保存
+	c.mutex.RLock()
+	changeCount := c.changeCount
+	lastSaveTime := c.lastSaveTime
+	lastSaveCacheSize := c.lastSaveCacheSize
+	lastSaveItemCount := c.lastSaveItemCount
+	currentCacheSize := c.cacheSize
+	currentItemCount := len(c.cache)
+	c.mutex.RUnlock()
+
+	// 检查是否需要保存
+	if changeCount < 10 {
+		return
+	}
+	if time.Since(lastSaveTime) < c.minSaveInterval {
+		return
+	}
+	if currentItemCount > 0 {
+		cacheSizeChange := float64(currentCacheSize-lastSaveCacheSize) / float64(lastSaveCacheSize+1) // +1避免除以零
+		itemCountChange := float64(currentItemCount-lastSaveItemCount) / float64(lastSaveItemCount+1) // +1避免除以零
+		if math.Abs(cacheSizeChange) < 0.1 && math.Abs(itemCountChange) < 0.1 {
+			return
+		}
+	}
+
+	// 开始保存缓存
+	c.mutex.RLock()
+	// 收集有效的缓存项
+	validItems := make(map[string]*SerializableDNSCacheItem)
+	now := time.Now()
+
+	for key, node := range c.cache {
+		// 只保存未过期的缓存项
+		if now.Before(node.value.Expiry) {
+			// 序列化DNS响应为二进制
+			responseBytes, err := node.value.Response.Pack()
+			if err != nil {
+				continue // 跳过无法序列化的响应
+			}
+
+			// 创建可序列化的缓存项
+			validItems[key] = &SerializableDNSCacheItem{
+				ResponseBytes: responseBytes,
+				Expiry:        node.value.Expiry.UnixNano(),
+				HasDNSSEC:     node.value.HasDNSSEC,
+				Size:          node.value.Size,
+			}
+		}
+	}
+
+	// 创建可序列化的缓存结构
+	serializableCache := &SerializableDNSCache{
+		Items:         validItems,
+		TTL:           int64(c.ttl),
+		MaxSize:       c.maxSize,
+		CacheMode:     c.cacheMode,
+		CacheFilePath: c.cacheFilePath,
+	}
+	c.mutex.RUnlock()
+
+	// 序列化到JSON
+	data, err := json.MarshalIndent(serializableCache, "", "  ")
+	if err != nil {
+		return
+	}
+
+	// 确保目录存在
+	os.MkdirAll(cacheDir(), 0755)
+
+	// 保存到文件
+	err = ioutil.WriteFile(c.cacheFilePath, data, 0644)
+	if err != nil {
+		return
+	}
+
+	// 更新保存状态
+	c.mutex.Lock()
+	c.changeCount = 0
+	c.lastSaveTime = time.Now()
+	c.lastSaveCacheSize = currentCacheSize
+	c.lastSaveItemCount = currentItemCount
+	c.mutex.Unlock()
+}
+
+// SaveToFile 保存缓存到文件
+func (c *DNSCache) SaveToFile() {
+	// 检查缓存模式，如果不是file模式，直接返回
+	c.mutex.RLock()
+	mode := c.cacheMode
+	c.mutex.RUnlock()
+	if mode != "file" {
+		return
+	}
+
+	// 调用底层保存逻辑
+	c.saveCacheToFile()
+}
+
+// LoadFromFile 从文件加载缓存
+func (c *DNSCache) LoadFromFile() {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+
+	// 检查文件是否存在
+	if _, err := os.Stat(c.cacheFilePath); os.IsNotExist(err) {
+		return // 文件不存在，跳过加载
+	}
+
+	// 读取文件内容
+	data, err := ioutil.ReadFile(c.cacheFilePath)
+	if err != nil {
+		return
+	}
+
+	// 反序列化JSON
+	var serializableCache SerializableDNSCache
+	err = json.Unmarshal(data, &serializableCache)
+	if err != nil {
+		return
+	}
+
+	// 加载缓存项
+	now := time.Now()
+	for key, serializableItem := range serializableCache.Items {
+		// 转换过期时间
+		expiry := time.Unix(0, serializableItem.Expiry)
+		// 只加载未过期的缓存项
+		if now.Before(expiry) {
+			// 反序列化二进制DNS响应
+			response := &dns.Msg{}
+			err := response.Unpack(serializableItem.ResponseBytes)
+			if err != nil {
+				continue // 跳过无法反序列化的响应
+			}
+
+			// 创建缓存项
+			item := &DNSCacheItem{
+				Response:  response,
+				Expiry:    expiry,
+				HasDNSSEC: serializableItem.HasDNSSEC,
+				Size:      serializableItem.Size,
+			}
+
+			// 创建新的链表节点并添加到尾部
+			newNode := &LRUNode{
+				key:   key,
+				value: item,
+			}
+			c.addNodeToTail(newNode)
+			c.cache[key] = newNode
+			c.cacheSize += int64(item.Size)
+		}
+	}
+}
+
+// cacheDir 返回缓存目录
+func cacheDir() string {
+	return "data"
+}
+
+// SetMaxCacheTTL 设置最大缓存TTL
+func (c *DNSCache) SetMaxCacheTTL(ttl time.Duration) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.maxCacheTTL = ttl
+}
+
+// SetMinCacheTTL 设置最小缓存TTL
+func (c *DNSCache) SetMinCacheTTL(ttl time.Duration) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.minCacheTTL = ttl
+}
+
+// SetCacheMode 设置缓存模式
+func (c *DNSCache) SetCacheMode(mode string) {
+	c.mutex.Lock()
+	oldMode := c.cacheMode
+	c.mutex.Unlock()
+
+	// 根据模式变化决定是否启动或停止保存循环
+	if oldMode != mode {
+		if oldMode == "file" {
+			// 从file模式切换到其他模式，先保存当前缓存到文件
+			// 直接调用底层保存逻辑，不检查缓存模式
+			c.saveCacheToFile()
+		}
+
+		c.mutex.Lock()
+		c.cacheMode = mode
+		c.mutex.Unlock()
+
+		if mode == "file" {
+			// 切换到file模式，启动保存循环
+			c.startSaveLoop()
+		} else {
+			// 切换到非file模式，停止保存循环
+			c.saveLoopMutex.Lock()
+			if c.saveRunning {
+				close(c.saveStopCh)
+				c.saveRunning = false
+			}
+			c.saveLoopMutex.Unlock()
+		}
+	}
+}
+
+// SetMaxCacheSize 设置最大缓存大小
+func (c *DNSCache) SetMaxCacheSize(size int64) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	c.maxCacheSize = size
+}
+
+// cleanupExpired 清理过期的缓存项，并返回下一次清理间隔的建议值
+func (c *DNSCache) cleanupExpired() time.Duration {
 	now := time.Now()
 
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
 
-	for key, item := range c.cache {
-		if now.After(item.Expiry) {
-			delete(c.cache, key)
+	// 收集所有过期的键
+	var expiredKeys []string
+	totalItems := len(c.cache)
+
+	// 遍历缓存，收集过期项
+	for key, node := range c.cache {
+		if now.After(node.value.Expiry) {
+			expiredKeys = append(expiredKeys, key)
 		}
 	}
+
+	expiredCount := len(expiredKeys)
+
+	// 智能清理策略
+	// 1. 如果过期项比例超过50%，立即清理
+	// 2. 如果缓存大小超过最大缓存大小的80%，清理过期项
+	// 3. 如果缓存项数量超过最大条目数的80%，清理过期项
+	needCleanup := false
+	if totalItems > 0 {
+		if float64(expiredCount)/float64(totalItems) > 0.5 {
+			needCleanup = true
+		} else if c.cacheSize > c.maxCacheSize*8/10 {
+			needCleanup = true
+		} else if totalItems > c.maxSize*8/10 {
+			needCleanup = true
+		}
+	}
+
+	// 如果没有过期项或不需要清理，根据过期项比例返回建议的清理间隔
+	if expiredCount == 0 || !needCleanup {
+		// 计算下一次清理间隔
+		var nextInterval time.Duration
+		if totalItems == 0 {
+			// 空缓存，下一次清理间隔可以长一些
+			nextInterval = 5 * time.Minute
+		} else {
+			expireRatio := float64(expiredCount) / float64(totalItems)
+			// 过期项比例越高，清理间隔越短
+			if expireRatio < 0.1 {
+				nextInterval = 5 * time.Minute
+			} else if expireRatio < 0.3 {
+				nextInterval = 2 * time.Minute
+			} else {
+				nextInterval = 1 * time.Minute
+			}
+		}
+		return nextInterval
+	}
+
+	// 删除过期的缓存项
+	for _, key := range expiredKeys {
+		if node, found := c.cache[key]; found {
+			// 减去缓存项大小
+			c.cacheSize -= int64(node.value.Size)
+			delete(c.cache, key)
+			c.removeNode(node)
+		}
+	}
+
+	// 清理后，如果缓存大小仍然超过最大缓存大小，继续清理最久未使用的项
+	if c.cacheSize > c.maxCacheSize {
+		// 计算需要清理的额外大小
+		overflow := c.cacheSize - c.maxCacheSize
+		cleanedSize := int64(0)
+
+		// 从链表头开始清理（最久未使用的项）
+		current := c.head
+		for current != nil && cleanedSize < overflow {
+			nextNode := current.next
+			cleanedSize += int64(current.value.Size)
+
+			// 删除节点
+			delete(c.cache, current.key)
+			c.removeNode(current)
+
+			current = nextNode
+		}
+	}
+
+	// 清理后，如果缓存项数量仍然超过最大条目数，继续清理最久未使用的项
+	if len(c.cache) > c.maxSize {
+		// 计算需要清理的额外数量
+		overflowCount := len(c.cache) - c.maxSize
+
+		// 从链表头开始清理（最久未使用的项）
+		current := c.head
+		for i := 0; i < overflowCount && current != nil; i++ {
+			nextNode := current.next
+
+			// 删除节点
+			c.cacheSize -= int64(current.value.Size)
+			delete(c.cache, current.key)
+			c.removeNode(current)
+
+			current = nextNode
+		}
+	}
+
+	// 清理后，根据剩余过期项比例返回建议的清理间隔
+	// 重新计算剩余过期项
+	var remainingExpired int
+	for _, node := range c.cache {
+		if now.After(node.value.Expiry) {
+			remainingExpired++
+		}
+	}
+
+	remainingItems := len(c.cache)
+	var nextInterval time.Duration
+	if remainingItems == 0 {
+		nextInterval = 5 * time.Minute
+	} else {
+		remainingRatio := float64(remainingExpired) / float64(remainingItems)
+		// 剩余过期项比例越高，清理间隔越短
+		if remainingRatio < 0.1 {
+			nextInterval = 5 * time.Minute
+		} else if remainingRatio < 0.3 {
+			nextInterval = 2 * time.Minute
+		} else {
+			nextInterval = 1 * time.Minute
+		}
+	}
+
+	return nextInterval
 }