热点缓存探测系统

public class HotKeyDetector {
    private final int WINDOW_SIZE = 10; // 滑动窗口大小
    private final int THRESHOLD = 5; // 阈值，达到该条件时即判定为热 Key
    private final Cache<String, Obejct> hotCache = CacheBuilder.newBuilder() // 本地缓存
            .expireAfterWrite(5, TimeUnit.SECONDS)
            .maximumSize(1000) // 缓存最大容量
            .build();

    private Map<String, Queue<Long>> window = new HashMap<>(); // 滑动窗口        
    private Map<String, Integer> counts = new HashMap<>(); // 用来计数，用来和阈值比较

    // 判断是否为热 Key
    public boolean isHotKey(String data) {
        // 如果缓存中有数据，说明已经是 hot key，直接返回 true
        if (hotCache.getIfPresent(data) != null) {
            return true;
        }
        // 获取当前数据在计数器中的统计次数
        int count = counts.getOrDefault(data, 0);
        // 如果次数大于阈值，说明是热 Key，将数据加入本地缓存，清空队列并返回 true
        if (count > THRESHOLD) {
            hotCache.put(data, data); // 加入本地缓存
            clear(data) // 清空滑动窗口中相应的队列
            return true;
        } else {
            // 如果次数小于阈值，说明不是热 Key，将数据加入滑动窗口，并返回 false
            counts.put(data, count + 1); // 次数加 1
            // 获取对应数据的时间队列
            Queue<Long> queue = window.get(data);
            // 如果队列不存在，就创建一个新的队列
            if (queue == null) {
                queue = new LinkedList<Long>();
                window.put(data, queue);
            }
            // 获取当前时间（秒）
            long currentTime = System.currentTimeMillis() / 1000;
            queue.add(currentTime); // 将当前时间加入队列，用于后面数据滑动窗口的统计
            // 如果队列中数据的时间超过了滑动窗口的时间区间，则将该时间从队列中移除
            while (!queue.isEmpty() && currentTime - queue.peek() > WINDOW_SIZE) {
                queue.poll(); // 移除队列头部的时间
                counts.put(data, counts.get(data) - 1); // 统计次数减 1
            }
            return false; // 不是热 Key，返回 false
        }
    }

    // 清除指定数据的队列和计数
    public void clear(String data) {
        window.remove(data); // 移除指定数据的队列
        counts.remove(data); // 移除指定数据的计数
    }

    // 添加数据到本地缓存
    public void set(String key, Object value) {
        hotCache.put(key, value); // 将数据加入本地缓存
    }

    // 从本地缓存中获取数据
    public Object get(String key) {
        return hotCache.getIfPresent(key); // 从本地缓存中获取数据
    }
}

type TimeWindow struct {
	requests []int64     // 存储请求时间戳
	size     int         // 窗口大小（请求次数限制）
	duration int64       // 窗口时间范围（纳秒）
}

func NewTimeWindow(size int, duration time.Duration) *TimeWindow {
	return &TimeWindow{
		requests: make([]int64, 0, size),
		size:     size,
		duration: duration.Nanoseconds(),
	}
}

// 检查是否允许通过
func (tw *TimeWindow) Allow() bool {
	now := time.Now().UnixNano()
	
	// 移除过期请求
	for len(tw.requests) > 0 && now-tw.requests[0] > tw.duration {
		tw.requests = tw.requests[1:]
	}
	
	// 检查是否超过限制
	if len(tw.requests) >= tw.size {
		return false
	}
	
	// 记录当前请求
	tw.requests = append(tw.requests, now)
	return true
}