读写对象

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写map工具类
 * @param <T>
 */
public abstract class ReadWriteMapUtil<T>{

    // 1. 构建一个支持过期的本地缓存（核心配置）
    private Cache<String, T> expirableCache;

    /**
     * 构造方法
     * @param outTime 过期时间(单位分钟)
     * @param maxSize 最大缓存数量
     */
    public ReadWriteMapUtil(int outTime,int maxSize){
        expirableCache = CacheBuilder.newBuilder()
                // 过期策略1：写入后多久过期（例如：写入5秒后过期）
                .expireAfterWrite(outTime, TimeUnit.MINUTES)
                // 可选：过期策略2：访问后多久过期（例如：5秒内未访问则过期）
                // .expireAfterAccess(5, TimeUnit.SECONDS)
                // 可选：设置缓存最大容量（防止内存溢出）
                .maximumSize(maxSize)
                // 可选：开启缓存统计（便于监控）
                .recordStats()
                .build();
    }

    // 读写锁核心对象（公平锁模式，避免写操作饥饿）
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    // 读锁（共享锁）
    private final java.util.concurrent.locks.Lock readLock = readWriteLock.readLock();
    // 写锁（排他锁）
    private final java.util.concurrent.locks.Lock writeLock = readWriteLock.writeLock();

    /**
     * 执行写操作（自动加/释放写锁）
     * @param key key
     * @param obj 对象
     */
    public void executeWrite(String key,T obj) {
        if (obj == null) {
            return;
        }
        // 加写锁（排他锁，此时所有读/写操作都会被阻塞）
        writeLock.lock();
        try {
            // 执行写逻辑
            expirableCache.put(key,obj);
        } finally {
            // 确保锁最终释放，避免死锁
            writeLock.unlock();
        }
    }

    /**
     * 执行带返回值的写操作（自动加/释放写锁）
     * @param key key
     * @param obj 对象
     * @return 写操作结果
     */
    public T executeWriteWithResult(String key,T obj) {
        if (obj == null) {
            return null;
        }
        writeLock.lock();
        try {
            expirableCache.put(key,obj);
            return obj;
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 执行读操作（自动加/释放读锁）
     * @param key key
     * @return 缓存对象
     */
    public T executeRead(String key) {
        // 加读锁（共享锁，此时所有写操作都会被阻塞）
        readLock.lock();
        try {
            // 执行读逻辑
            return expirableCache.getIfPresent(key);
        } finally {
            // 确保锁最终释放，避免死锁
            readLock.unlock();
            return null;
        }
    }
}