自定义map缓存的简单实现

/ 冷姿势 / 2 条评论 / 425人围观

定义一个工具类

public class MapCache {
    
}

属性和构造方法

    /**
     * 默认存储1024个缓存
     */
    private static final int DEFAULT_CACHES = 1024;

    private static final MapCache INS = new MapCache();

    /**
     * 缓存容器
     */
    private Map<String, CacheObject> cachePool;

    public static MapCache single() {
        return INS;
    }
    
    public MapCache() {
        this(DEFAULT_CACHES);
    }

    public MapCache(int cacheCount) {
        cachePool = new ConcurrentHashMap(cacheCount);
    }

初始化容量,设置成单例模式

设置一个静态内部类用存储数据

    static class CacheObject {
        private String key;
        private Object value;
        private long expired;

        public CacheObject(String key, Object value, long expired) {
            this.key = key;
            this.value = value;
            this.expired = expired;
        }

        public String getKey() {
            return key;
        }

        public Object getValue() {
            return value;
        }

        public long getExpired() {
            return expired;
        }
    }

设置一个set

    /**
     * 设置一个缓存并带过期时间
     * @author 70kg
     * @param key     缓存key
     * @param value   缓存value
     * @param expired 过期时间,单位为秒
     */
    public void set(String key, Object value, long expired) {
        expired = expired > 0 ? System.currentTimeMillis() / 1000 + expired : expired;
        CacheObject cacheObject = new CacheObject(key, value, expired);
        cachePool.put(key, cacheObject);
    }

设置一个hash

    /**
     * 设置一个hash缓存并带过期时间
     * @author 70kg
     * @param key     缓存key
     * @param field   缓存field
     * @param value   缓存value
     * @param expired 过期时间,单位为秒
     */
    public void hset(String key, String field, Object value, long expired) {
        key = key + ":" + field;
        expired = expired > 0 ? System.currentTimeMillis() / 1000 + expired : expired;
        CacheObject cacheObject = new CacheObject(key, value, expired);
        cachePool.put(key, cacheObject);
    }

读取缓存

    /**
     * 读取一个缓存
     * @author 70kg
     * @param key 缓存key
     * @param <T>
     * @return
     */
    public <T> T get(String key) {
        CacheObject cacheObject = cachePool.get(key);
        if (null != cacheObject) {
            long cur = System.currentTimeMillis() / 1000;
            if (cacheObject.getExpired() <= 0 || cacheObject.getExpired() > cur) {
                Object result = cacheObject.getValue();
                return (T) result;
            }
        }
        return null;
    }

删除清除缓存

    /**
     * 根据key删除缓存
     *
     * @param key 缓存key
     */
    public void del(String key) {
        cachePool.remove(key);
    }

    /**
     * 根据key和field删除缓存
     *
     * @param key   缓存key
     * @param field 缓存field
     */
    public void hdel(String key, String field) {
        key = key + ":" + field;
        this.del(key);
    }

    /**
     * 清空缓存
     */
    public void clean() {
        cachePool.clear();
    }

最后再一点

ConcurrentHashMap,听名字就很牛气,并发的hashmap。其实早在jdk1.5,大约2010年左右,sun的大爷们就推出了ConcurrentHashMap,线程安全,读写还快。你这不是蒙我呢,线程安全和读写速度肯定是成反比的,怎么可能。看了源码才知道,这是一种以空间换时间的结构,跟分布式缓存结构有点像,创建的时候,内存直接分为了16个segment,每个segment实际上还是存储的哈希表,写入的时候,先找到对应的segment,然后锁这个segment,写完,解锁,汗!就这么简单解决了,锁segment的时候,其他segment还可以继续工作。好像听着挺简单的,其实大爷们的代码看着真的很头疼,到处都是移位、与或非,就拿计算存放位置的代码来看,如何均匀的散列,减少位置碰撞都是有讲究的,还是得感叹你大爷就是你大爷,真牛啊可是。欢迎留言呐老哥们。

  1. 666666

    回复
  2. k000000000

    回复