实现一个 LRU 缓存，当缓存数据达到 N 之后需要淘汰掉最近最少使用的数据。N 小时之内没有被访问的数据也需要淘汰掉

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class SmartLRUCache<K, V> {

    private final int capacity;
    private final long expireTimeMs; // 过期时间（毫秒）

    // 内部类，保存值和最后访问时间戳
    private static class Node<V> {
        V value;
        long lastAccessTime;

        Node(V value) {
            this.value = value;
            this.lastAccessTime = System.currentTimeMillis();
        }
    }

    private final LinkedHashMap<K, Node<V>> cache;

    public SmartLRUCache(int capacity, int expireHours) {
        this.capacity = capacity;
        this.expireTimeMs = expireHours * 60 * 60 * 1000L;

        // accessOrder 为 true，开启 LRU 模式
        this.cache = new LinkedHashMap<K, Node<V>>(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, Node<V>> eldest) {
                // 空间维度淘汰：超过容量就删掉最近最少使用的
                return size() > SmartLRUCache.this.capacity;
            }
        };
    }

    // 同步方法保证线程安全（实际高并发可用 ConcurrentHashMap + 手写双向链表）
    public synchronized void put(K key, V value) {
        cache.put(key, new Node<>(value));
    }

    public synchronized V get(K key) {
        Node<V> node = cache.get(key);
        if (node == null) {
            return null;
        }

        // 时间维度淘汰：N 小时内没访问
        long now = System.currentTimeMillis();
        if (now - node.lastAccessTime > expireTimeMs) {
            cache.remove(key); // 已过期
            return null;
        }

        // 更新最后访问时间并返回
        node.lastAccessTime = now;
        return node.value;
    }

    // 可选：后台清理线程调用的方法，防止内存中堆积过期的死数据
    public synchronized void clearExpired() {
        long now = System.currentTimeMillis();
        cache.entrySet().removeIf(entry -> (now - entry.getValue().lastAccessTime) > expireTimeMs);
    }
}