java 过期缓存

Java中过期缓存可以通过使用java.util.concurrent包中的ConcurrentHashMap和ScheduledExecutorService实现。具体实现过程如下：

1. 创建一个ConcurrentHashMap对象，用于存储缓存数据。

2. 使用ScheduledExecutorService定时清理过期数据，具体实现可以通过使用ScheduledThreadPoolExecutor或者Timer类来实现。

3. 在向缓存中添加数据时，将数据的过期时间也存储起来，以便在清理过期数据时可以判断哪些数据已经过期。

4. 当从缓存中获取数据时，需要判断数据是否过期，如果已经过期则移除缓存中的数据并返回null。

5. 在系统关闭时需要清理缓存中的所有数据。

示例代码如下：

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ExpiringCache<K, V> {
    private final ConcurrentHashMap<K, ExpiringValue<V>> cache = new ConcurrentHashMap<>();
    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1, new ThreadFactory() {
        private final AtomicInteger threadNumber = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r, "ExpiringCache-" + threadNumber.getAndIncrement());
        }
    });

    private static class ExpiringValue<V> {
        final V value;
        final long expirationTime;

        ExpiringValue(V value, long expirationTime) {
            this.value = value;
            this.expirationTime = expirationTime;
        }
    }

    public void put(K key, V value, long expirationTime, TimeUnit timeUnit) {
        long expirationTimestamp = System.currentTimeMillis() + timeUnit.toMillis(expirationTime);
        cache.put(key, new ExpiringValue<>(value, expirationTimestamp));
    }

    public V get(K key) {
        ExpiringValue<V> expiringValue = cache.get(key);
        if (expiringValue != null) {
            if (System.currentTimeMillis() < expiringValue.expirationTime) {
                return expiringValue.value;
            } else {
                cache.remove(key);
            }
        }
        return null;
    }

    public void clear() {
        cache.clear();
    }

    public void shutdown() {
        executor.shutdown();
    }

    public ExpiringCache() {
        executor.scheduleAtFixedRate(() -> {
            long now = System.currentTimeMillis();
            cache.forEach((key, value) -> {
                if (now > value.expirationTime) {
                    cache.remove(key);
                }
            });
        }, 0, 1, TimeUnit.SECONDS);
    }
}

这是一个简单的过期缓存的实现，使用起来也比较方便。