17370845950

答案：Java中实现线程安全的LRU缓存可通过继承LinkedHashMap并同步访问，或用ConcurrentHashMap与双向链表手动实现；前者简单但性能低，后者结合读写锁提升并发效率，适用于高并发场景。

在Java中实现线程安全的LRU（Least Recently Used）缓存，核心是结合双向链表和哈希表，并确保多线程环境下的操作安全。可以通过继承 LinkedHashMap 或手动实现一个支持并发访问的数据结构来完成。

使用继承 LinkedHashMap 实现线程安全 LRU 缓存

Java 的 LinkedHashMap 提供了维护插入或访问顺序的能力，通过重写 removeEldestEntry 方法可以轻松实现 LRU 策略。为了保证线程安全，需要用 Collections.synchronizedMap 包装或直接使用同步代码块。

示例代码：

public class SynchronizedLRUCache extends LinkedHashMap {
    private final int capacity;

    public SynchronizedLRUCache(int capacity) {
        super(capacity, 0.75f, true); // true 表示按访问顺序排序
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry eldest) {
        return size() > capacity;
    }

    // 必须外部同步访问
    private final Object lock = new Object();

    public V get(K key) {
        synchronized (lock) {
            return super.get(key);
        }
    }

    public V put(K key, V value) {
        synchronized (lock) {
            return super.put(key, value);
        }
    }
}

注意：虽然 LinkedHashMap 本身不是线程安全的，但通过对象锁保护 get 和 put 操作，可实现基本的线程安全。

使用 ConcurrentHashMap + 双向链表手动实现

更高效且灵活的方式是自己维护一个双向链表与 ConcurrentHashMap 配合，这样能避免锁整个 map，提高并发性能。

关键点：

• 用 ConcurrentHashMap 存储 key 到节点的映射
• 用自定义的双向链表管理访问顺序，最近使用的放头部，淘汰时从尾部移除
• 每个操作使用细粒度锁或原子操作保证一致性

示例结构：

class Node {
    K key;
    V value;
    Node prev;
    Node next;
    // 构造函数...
}

缓存类中包含：

• head 和 tail 指针用于维护链表
• map: ConcurrentHashMap>
• 容量限制和当前大小
• 所有修改操作加锁（可用 ReentrantLock）

get 操作流程：

• 从 map 中查找节点
• 若存在，将其移到链表头部（表示最新使用）
• 返回值

put 操作流程：

• 若 key 已存在，更新值并移至头部
• 否则创建新节点插入头部
• 检查是否超容，若是则删除尾部节点及其在 map 中的引用

使用 Java 内置并发工具优化

为提升性能，可考虑：

• 使用 ReentrantReadWriteLock：读操作共享锁，写操作独占锁，适合读多写少场景
• 将链表操作与 map 操作统一在同一锁下，避免竞态条件
• 控制锁粒度，尽量减少同步代码块范围

例如：

private final ReadWriteLock lock = new ReentrantReadWriteLock();
private final Lock readLock = lock.readLock();
private final Lock writeLock = lock.writeLock();

get 方法使用 readLock，put 使用 writeLock。