精华内容
下载资源
问答
  • 过期地图 用Java编写的过期时间设置的Expirable Map 样本 Map<Integer> map = new CacheMap(1000 * 5); map.put(1, "value"); 然后map.get(1)将在 5 分钟后过期
  • 主要介绍了Java缓存Map设置过期时间实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 有失效时间Map

    千次阅读 2019-07-20 15:08:40
    今天是一个周六还要上班的苦逼...于是想到写到内存里,由于数据表结构比较适合Map存储,于是想写到Map,但是由于新增的数据不是在一个服务里面,需要对这个Map设置失效时间,稍微提升一点数据的准确性。 这里展示...

    今天是一个周六还要上班的苦逼孩子

    今天遇到了一个数据,由于在Socket中会用到,使用比较频繁,但是新增的数据很少,不想每次都需要查询数据库,但是也犯不着也到缓存里(新增数据和查询不是在一个服务里面,没有集成redis)

    于是想到写到内存里,由于数据表结构比较适合Map存储,于是想写到Map,但是由于新增的数据不是在一个服务里面,需要对这个Map设置失效时间,稍微提升一点数据的准确性。


    这里展示的没有涉及到需要顾及线程安全的失效Map

    帮助类

    package com.hiqiblog.util;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /**
     *
     * @Description: 带有效期map 简单实现 实现了基本的方法
     * @author ww
     * @date: 2019-07-20
     * @param <K>
     * @param <V>
     */
    public class ExpiryMap<K, V> extends HashMap<K, V> {
    
        private static final long serialVersionUID = 1L;
    
        /**
         * default expiry time 5分钟
         */
        private long EXPIRY = 1000 ;
    
        private HashMap<K, Long> expiryMap = new HashMap<K, Long>();
    
        public ExpiryMap(){
            super();
        }
        public ExpiryMap(long defaultExpiryTime){
            this(1 << 4, defaultExpiryTime);
        }
        public ExpiryMap(int initialCapacity, long defaultExpiryTime){
            super(initialCapacity);
            this.EXPIRY = defaultExpiryTime;
        }
        @Override
        public V put(K key, V value) {
            expiryMap.put(key, System.currentTimeMillis() + EXPIRY);
            return super.put(key, value);
        }
        @Override
        public boolean containsKey(Object key) {
            return !checkExpiry(key, true) && super.containsKey(key);
        }
        /**
         * @param key
         * @param value
         * @param expiryTime 键值对有效期 毫秒
         * @return
         */
        public V put(K key, V value, long expiryTime) {
            expiryMap.put(key, System.currentTimeMillis() + expiryTime);
            return super.put(key, value);
        }
        @Override
        public int size() {
            return entrySet().size();
        }
        @Override
        public boolean isEmpty() {
            return entrySet().size() == 0;
        }
        @Override
        public boolean containsValue(Object value) {
            if (value == null){
                return Boolean.FALSE;
            }
            Set<Entry<K, V>> set = super.entrySet();
            Iterator<Entry<K, V>> iterator = set.iterator();
            while (iterator.hasNext()) {
                java.util.Map.Entry<K, V> entry = iterator.next();
                if(value.equals(entry.getValue())){
                    if(checkExpiry(entry.getKey(), false)) {
                        iterator.remove();
                        return Boolean.FALSE;
                    }else{
                        return Boolean.TRUE;
                    }
                }
            }
            return Boolean.FALSE;
        }
        @Override
        public Collection<V> values() {
    
            Collection<V> values = super.values();
    
            if(values == null || values.size() < 1){
                return values;
            }
    
            Iterator<V> iterator = values.iterator();
    
            while (iterator.hasNext()) {
                V next = iterator.next();
                if(!containsValue(next)) {
                    iterator.remove();
                }
            }
            return values;
        }
        @Override
        public V get(Object key) {
            if (key == null){
                return null;
            }
    
            if(checkExpiry(key, true)){
                return null;
            }
            return super.get(key);
        }
        /**
         * @Description: 是否过期
         * @return null:不存在或key为null -1:过期  存在且没过期返回value 因为过期的不是实时删除,所以稍微有点作用
         * @param key
         * @return
         */
        public Object isInvalid(Object key) {
            if (key == null){
                return null;
            }
    
            if(!expiryMap.containsKey(key)){
                return null;
            }
            long expiryTime = expiryMap.get(key);
    
            boolean flag = System.currentTimeMillis() > expiryTime;
    
            if(flag){
                super.remove(key);
                expiryMap.remove(key);
                return -1;
            }
            return super.get(key);
        }
        @Override
        public void putAll(Map<? extends K, ? extends V> m) {
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()){
                expiryMap.put(e.getKey(), System.currentTimeMillis() + EXPIRY);
            }
            super.putAll(m);
        }
        @Override
        public Set<Map.Entry<K,V>> entrySet() {
            Set<java.util.Map.Entry<K, V>> set = super.entrySet();
            Iterator<java.util.Map.Entry<K, V>> iterator = set.iterator();
            while (iterator.hasNext()) {
                java.util.Map.Entry<K, V> entry = iterator.next();
                if(checkExpiry(entry.getKey(), false)) {
                    iterator.remove();
                }
            }
    
            return set;
        }
        /**
         * @Description: 是否过期
         **/
        private boolean checkExpiry(Object key, boolean isRemoveSuper){
    
            if(!expiryMap.containsKey(key)){
                return Boolean.FALSE;
            }
            long expiryTime = expiryMap.get(key);
    
            boolean flag = System.currentTimeMillis() > expiryTime;
    
            if(flag){
                if(isRemoveSuper){
                    super.remove(key);
                }
                expiryMap.remove(key);
            }
            return flag;
        }
    
    }
    

    dataCache.java

    public class dataCache{
    
    private ExpiryMap<String,Map>  channelPropertiesMap;	
    
    public ExpiryMap<String, Map> getChannelPropertiesMap() {
    		if (channelPropertiesMap == null){
    			channelPropertiesMap = new ExpiryMap<String, Map>();
    		    PlatformService platformService = ContextHolder.getInstance().getSpringBean("platformService");
    		    List propertieslist = platformService.getChannelPropertieList();
    		    if (propertieslist!=null && propertieslist.size()>0) 
    		    {
    		       for(int i=0;i<propertieslist.size();i++){
    		    	   Map obj = (Map)propertieslist.get(i);
    		    	   channelPropertiesMap.put(obj.get("cid").toString(),obj);
    		       }
    		    }
    		}
    		return channelPropertiesMap;
    	}
    }
    

    platformService.java

     public String getChannelProperties(int cid) {
        	ExpiryMap<String, Map> channelProperties = dataCache.getInstance().getChannelPropertiesMap();
            Map map=channelProperties.get(String.valueOf(cid));
            String result="";
        	if(map == null){
        	    Object[] params = {cid};
        	    String sql = "SELECT value FROM gms_channel_properties c where c.cid=? and c.key='wx' limit 1";
        	    List propertieslist = getJdbcTemplate().queryForList(sql, params);
        		if (propertieslist!=null && propertieslist.size()>0) 
        		{
        		 	Map obj = (Map)propertieslist.get(0);
        		 	result = obj.get("value").toString();
        		 		
        		}
        	}else{
        		result = map.get("value").toString();
        	}
    	   
    		return result;
    	}
        public List getChannelPropertieList() {
    	    String sql = "SELECT c.key,c.value,c.cid FROM gms_channel_properties c";
    	    List propertieslist = getJdbcTemplate().queryForList(sql);
    		return propertieslist;
    	}
    

    然后研究了一下线程安全的,决定用concurrenthashmap实现

    帮助类

    package com.hiqiblog.util;
    
    import java.util.Iterator;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.concurrent.TimeUnit;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    
    /**
     * 实现延时过期MAP集合 支持自定义过期触发事件
     *
     * @Author helloc
     * @Date 2019/7/20 15:12
     * @Version 1.0
     * @param <K>
     * @param <V>
     */
    public abstract class SafeExpireMap<K, V> {
        protected static final Logger logger = LoggerFactory.getLogger(SafeExpireMap.class);
        private long expTime = 0L;
        private TimeUnit unit = null;
        /**
         * 线程安全的map容器
         */
        ConcurrentHashMap<K, V> expireMap = null;
        /**
         * 控制过期时间
         */
        ConcurrentHashMap<K, Long> delayMap = null;
    
        /**
         * 将map提供给外部程序操作
         * @Title: getDataMap
         * @Description: TODO
         * @return
         * @return: ConcurrentHashMap<K,V>
         */
        public ConcurrentHashMap<K, V> getDataMap(){
            return this.expireMap;
        }
    
        public SafeExpireMap(long expTime, TimeUnit unit) {
            expireMap = new ConcurrentHashMap<K, V>();
            delayMap = new ConcurrentHashMap<K, Long>();
            this.expTime = expTime;
            this.unit = unit;
            // 启动监听线程
            BaseExpireCheckTask task = new BaseExpireCheckTask(expireMap, delayMap) {
                @Override
                protected void expireEvent(K key,V val) {
                    baseExpireEvent(key,val);
                }
            };
            task.setDaemon(false);
            task.start();
        }
    
        /**
         * 过期事件 子类实现
         *
         * @Title: baseExpireEvent
         * @Description: TODO
         * @param key
         * @return: void
         */
        protected abstract void baseExpireEvent(K key,V val);
    
        public V put(K key, V val) {
            delayMap.put(key, getExpireTime());
            return expireMap.put(key, val);
        }
    
        public V remove(K key) {
            return expireMap.remove(key);
        }
    
        public V get(K key){
            return expireMap.get(key);
        }
    
        private Long getExpireTime() {
            return unit.toMillis(expTime) + System.currentTimeMillis();
        }
    
        public static void main(String[] args) {
            System.out.println(TimeUnit.SECONDS.toMinutes(120));
            System.out.println(TimeUnit.MICROSECONDS.toMillis(120));
            System.out.println(TimeUnit.MILLISECONDS.toMillis(120));
        }
    
        /**
         * 扫描线程 定期移除过期元素并触发过期事件
         *
         * @ClassName: BaseExpireCheckTask
         * @Description: TODO
         * @author: wangs
         * @date: 2017-12-25 上午9:59:18
         */
        private abstract class BaseExpireCheckTask extends Thread {
            ConcurrentHashMap<K, Long> delayMap = null;
            ConcurrentHashMap<K, V> expireMap = null;
    
            public BaseExpireCheckTask(ConcurrentHashMap<K, V> expireMap, ConcurrentHashMap<K, Long> delayMap) {
                this.delayMap = delayMap;
                this.expireMap = expireMap;
            }
    
            protected abstract void expireEvent(K key,V val);
            @Override
            public void run() {
                Iterator<K> it = null;
                K key = null;
                while (true) {
                    if (delayMap != null && !delayMap.isEmpty()) {
                        it = delayMap.keySet().iterator();
                        while (it.hasNext()) {
                            key = it.next();
                            if (delayMap.get(key) <= System.currentTimeMillis()) {
                                // 元素超时
                                // 触发回调
                                expireEvent(key,expireMap.get(key));
                                // 移除
                                it.remove();
                                expireMap.remove(key);
                                delayMap.remove(key);
                            }
                        }
                    }
                    try {
                        TimeUnit.MILLISECONDS.sleep(200);
                    } catch (InterruptedException e) {
                        logger.error(e.getMessage());
                    }
                }
            }
        }
    }
    
    展开全文
  • 带过期时间map实现

    2021-09-29 10:50:19
    import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set;... * @Description: 带过期时间map 每5分钟 一次回收 线程安全 * @Author: zcm * @Date:
    package com.linkage.system.utils;
    
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @Description: 带过期时间的map  每5分钟 一次回收  线程安全
     * @Author: zcm
     * @Date: 2020/4/29 16:03  用时3个小时  2020/4/30 10:16 完成
     */
    public class ExpiryConcurrentMap<K,V> implements Map<K,V> {
    
        private ConcurrentHashMap workMap ;
        private ConcurrentHashMap expiryMap ;
        /**
         * 默认保存时间2分钟
         */
        private long EXPIRYTIME =1000 * 60 * 2;
        /**
         *  circulation 循环时间  默认5分钟
         */
        private long CIRCULATIONTIME = 1000*60*5;
        /**
         *   delay 启动延迟时间  默认1分钟
         */
        private long DELAY = 1000*60;
    
        public ExpiryConcurrentMap() {
            this(16,0);
        }
        /**
         * 单位秒
         * @param expiryTime
         */
        public ExpiryConcurrentMap(long expiryTime) {
            this(16,expiryTime);
        }
        /**
         * 单位秒
         * @param initialCapacity
         * @param expiryTime
         */
        public ExpiryConcurrentMap(int initialCapacity, long expiryTime) {
            if(expiryTime>0)
                this.EXPIRYTIME = expiryTime *1000;
            workMap =new ConcurrentHashMap(initialCapacity);
            expiryMap =new ConcurrentHashMap(initialCapacity);
    //        定时任务清理map的过期数据
    //        new Timer().schedule(new TimerTask() {
    //            @Override
    //            public void run() {
    //                System.out.println("The Expiry Map size is "+size());
    //            }
    //        },DELAY,CIRCULATIONTIME);
        }
        /**
         * 使用 全局过期时间
         * @param key
         * @param value
         * @return
         */
        @Override
        public V put(K key, V value) {
            expiryMap.put(key, System.currentTimeMillis()+EXPIRYTIME);
            return (V)workMap.put(key, value);
        }
        /**
         * 使用 自定义过期时间 单位秒
         * @param key
         * @param value
         * @return
         */
        public V put(K key, V value,long exrity) {
            expiryMap.put(key, System.currentTimeMillis()+ exrity*1000);
            return (V) workMap.put(key, value);
        }
    
        private void removeExpiryKeys(){
    //        expiryMap.keySet().forEach(key->{
    //            checkExpiry((K) key,true);
    //        });
            Set set = expiryMap.keySet();
            for (Object o : set) {
                checkExpiry((K) o,true);
            }
        }
        /**
         * 是否过期判断函数
         * @param key
         * @param isDelete
         * @return 过期true  不过期false
         */
        private boolean checkExpiry(K key,boolean isDelete){
            Object timeObject =expiryMap.get(key);
            if(timeObject==null){
                return true;
            }
            long setTime = Long.parseLong(timeObject.toString()) ;
            boolean isExpiry = System.currentTimeMillis()-setTime>=0;
            if(isExpiry){
                if(isDelete){
                    expiryMap.remove(key);
                    workMap.remove(key);
                }
                return true;
            }
            return false;
        }
    
        @Override
        public V get(Object key) {
            boolean isExpiry = checkExpiry((K)key, true);
            if(isExpiry){
                return null;
            }
            return (V)workMap.get(key);
        }
    
        @Override
        public int size() {
            removeExpiryKeys();
            return workMap.size();
        }
        @Override
        public boolean isEmpty() {
            removeExpiryKeys();
            return workMap.isEmpty();
        }
    
        @Override
        public boolean containsKey(Object key) {
            removeExpiryKeys();
            return workMap.containsKey(key);
        }
    
        @Override
        public boolean containsValue(Object value) {
            removeExpiryKeys();
            return workMap.containsValue(value);
        }
    
        @Override
        public V remove(Object key) {
            expiryMap.remove(key);
            return (V)workMap.remove(key);
        }
    
        @Override
        public void putAll(Map<? extends K, ? extends V> m) {
    //        m.entrySet().forEach(en->{
    //            expiryMap.put(en.getKey(), System.currentTimeMillis()+EXPIRYTIME);
    //            workMap.put(en.getKey(),en.getValue());
    //        });
    
            Set<? extends Entry<? extends K, ? extends V>> entries = m.entrySet();
            for (Entry<? extends K, ? extends V> en : entries) {
                expiryMap.put(en.getKey(), System.currentTimeMillis()+EXPIRYTIME);
                workMap.put(en.getKey(),en.getValue());
            }
        }
    
        @Override
        public void clear() {
            expiryMap.clear();
            workMap.clear();
        }
    
        @Override
        public Set<K> keySet() {
            removeExpiryKeys();
            return workMap.keySet();
        }
    
        @Override
        public Collection<V> values() {
            removeExpiryKeys();
            return workMap.values();
        }
    
        @Override
        public Set<Entry<K, V>> entrySet() {
            removeExpiryKeys();
            return workMap.entrySet();
        }
    
        public void setCIRCULATIONTIME(long CIRCULATIONTIME) {
            this.CIRCULATIONTIME = CIRCULATIONTIME;
        }
    
        public void setDELAY(long DELAY) {
            this.DELAY = DELAY;
        }
    
        public long getCIRCULATIONTIME() {
            return CIRCULATIONTIME;
        }
    
        public long getDELAY() {
            return DELAY;
        }
    
        public static void main(String[] args) throws InterruptedException {
            ExpiryConcurrentMap<String, String> map = new ExpiryConcurrentMap<String, String>();
            map.put("1","1",3);//3秒过期
            map.put("2","2",10);//10秒过期
            map.put("3","3");//默认2分钟秒过期
            System.out.println( map.get("1"));
            System.out.println( map.get("2"));
            System.out.println( map.get("3"));
            Thread.sleep(5000);//过5秒
            System.out.println("map.size:"+map.size());
            Thread.sleep(1000*60*1);
            System.out.println( map.get("1"));
            System.out.println( map.get("2"));
            System.out.println( map.get("3"));
            map.put("1","1");
            map.put("2","2");
            map.put("3","3");
            HashMap<String, String> hashMap = new HashMap<String, String>();
            hashMap.put("4","4");
            hashMap.put("5","5");
            map.putAll(hashMap);
            System.out.println( map.size());
            System.out.println( map.values());
            System.out.println( map.entrySet());
            System.out.println( map.isEmpty());
            System.out.println( map.containsKey("1"));
            System.out.println( map.containsValue("2"));
            System.out.println( map.remove("1"));
            System.out.println( map.get("1"));
        }
    }
    
    
    
    展开全文
  • 带过期时间Map的实现

    千次阅读 2020-04-30 10:27:05
    最近刚刚上班,还在实习,工作比较轻松,研究下公司项目,有一个工具类就是带过期时间Map的实现,他的实现有点复杂,而且规范性也不好,在网上查了类似的博客,把两者的有点结合了起来,实现了自己的Map,二话不说...

    公司有一个工具类就是带过期时间的Map的实现,它的实现有点复杂,而且规范性也不好,在网上查了类似的博客,把两者的优点结合了起来,实现了自己的Map,二话不说直接上代码,希望大家多多提下意见,欢迎评论。

    package com.zcm.demo.utils;
    
    import java.util.*;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @Description: 带过期时间的map  每5分钟 一次回收  线程安全
     * @Author: zcm
     * @Date: 2020/4/29 16:03  用时3个小时  2020/4/30 10:16 完成
     */
    public class ExpiryMap<K,V> implements Map<K,V>{
    
        private ConcurrentHashMap workMap ;
        private ConcurrentHashMap expiryMap ;
        /**
         * 默认保存时间2分钟
         */
        private long EXPIRYTIME =1000 * 60 * 2;
        /**
         *  circulation 循环时间  默认5分钟
         */
        private long CIRCULATIONTIME = 1000*60*5;
        /**
         *   delay 启动延迟时间  默认1分钟
         */
        private long DELAY = 1000*60;
    
        public ExpiryMap() {
            this(16,0);
        }
        /**
         * 单位秒
         * @param expiryTime
         */
        public ExpiryMap(long expiryTime) {
            this(16,expiryTime);
        }
        /**
         * 单位秒
         * @param initialCapacity
         * @param expiryTime
         */
        public ExpiryMap(int initialCapacity, long expiryTime) {
           if(expiryTime>0)
               this.EXPIRYTIME = expiryTime *1000;
            workMap =new ConcurrentHashMap(initialCapacity);
            expiryMap =new ConcurrentHashMap(initialCapacity);
            new Timer().schedule(new TimerTask() {
                @Override
                public void run() {
                    System.out.println("The Expiry Map size is "+size());
                }
            },DELAY,CIRCULATIONTIME);
        }
        /**
         * 使用 全局过期时间
         * @param key
         * @param value
         * @return
         */
        @Override
        public V put(K key, V value) {
            expiryMap.put(key,System.currentTimeMillis()+EXPIRYTIME);
            return (V)workMap.put(key, value);
        }
        /**
         * 使用 自定义过期时间 单位秒
         * @param key
         * @param value
         * @return
         */
        public V put(K key, V value,long exrity) {
            expiryMap.put(key,System.currentTimeMillis()+ exrity*1000);
            return (V) workMap.put(key, value);
        }
    
        private void removeExpiryKeys(){
            expiryMap.keySet().forEach(key->{
                checkExpiry((K) key,true);
            });
        }
        /**
         * 是否过期判断函数
         * @param key
         * @param isDelete
         * @return 过期true  不过期false
         */
        private boolean checkExpiry(K key,boolean isDelete){
            Object timeObject =expiryMap.get(key);
            if(timeObject==null){
                return true;
            }
            long setTime = (long) timeObject;
            boolean isExpiry = System.currentTimeMillis()-setTime>=0;
            if(isExpiry){
                if(isDelete){
                    expiryMap.remove(key);
                    workMap.remove(key);
                }
                return true;
            }
            return false;
        }
    
        @Override
        public V get(Object key) {
            boolean isExpiry = checkExpiry((K)key, true);
            if(isExpiry){
                return null;
            }
            return (V)workMap.get(key);
        }
    
        @Override
        public int size() {
            removeExpiryKeys();
            return workMap.size();
        }
        @Override
        public boolean isEmpty() {
            removeExpiryKeys();
            return workMap.isEmpty();
        }
    
        @Override
        public boolean containsKey(Object key) {
            removeExpiryKeys();
            return workMap.containsKey(key);
        }
    
        @Override
        public boolean containsValue(Object value) {
            removeExpiryKeys();
            return workMap.containsValue(value);
        }
    
        @Override
        public V remove(Object key) {
            expiryMap.remove(key);
            return (V)workMap.remove(key);
        }
    
        @Override
        public void putAll(Map<? extends K, ? extends V> m) {
            m.entrySet().forEach(en->{
                expiryMap.put(en.getKey(),System.currentTimeMillis()+EXPIRYTIME);
                workMap.put(en.getKey(),en.getValue());
            });
        }
    
        @Override
        public void clear() {
            expiryMap.clear();
            workMap.clear();
        }
    
        @Override
        public Set<K> keySet() {
            removeExpiryKeys();
            return workMap.keySet();
        }
    
        @Override
        public Collection<V> values() {
            removeExpiryKeys();
            return workMap.values();
        }
    
        @Override
        public Set<Entry<K, V>> entrySet() {
            removeExpiryKeys();
            return workMap.entrySet();
        }
    
        public void setCIRCULATIONTIME(long CIRCULATIONTIME) {
            this.CIRCULATIONTIME = CIRCULATIONTIME;
        }
    
        public void setDELAY(long DELAY) {
            this.DELAY = DELAY;
        }
    
        public long getCIRCULATIONTIME() {
            return CIRCULATIONTIME;
        }
    
        public long getDELAY() {
            return DELAY;
        }
    
        public static void main(String[] args) throws InterruptedException {
    //        ExpiryMap<String, String> map = new ExpiryMap<>();
    //        map.put("1","1",3);
    //        map.put("2","2",10);
    //        map.put("3","3");
    //        System.out.println( map.get("1"));
    //        System.out.println( map.get("2"));
    //        System.out.println( map.get("3"));
    //        Thread.sleep(10000);
    //        map.size();
    //        Thread.sleep(1000*60*2);
    //        System.out.println( map.get("1"));
    //        System.out.println( map.get("2"));
    //        System.out.println( map.get("3"));
    //        map.put("1","1");
    //        map.put("2","2");
    //        map.put("3","3");
    //        HashMap<String, String> hashMap = new HashMap<>();
    //        hashMap.put("4","4");
    //        hashMap.put("5","5");
    //        map.putAll(hashMap);
    //        System.out.println( map.size());
    //        System.out.println( map.values());
    //        System.out.println( map.entrySet());
    //        System.out.println( map.isEmpty());
    //        System.out.println( map.containsKey("1"));
    //        System.out.println( map.containsValue("2"));
    //        System.out.println( map.remove("1"));
    //        System.out.println( map.get("1"));
        }
    }
    
    
    展开全文
  • 创建带过期时间map

    2019-12-31 11:27:46
    /** * */ package cn.article.utils; /** * Title: ExpireMap * @version V1.0 * Description: 设置map过期时间 */ import java.util.Collection; import java.util.HashMap; import java.util.Iterator;...

    /**
     * 
     */
    package cn.article.utils;
     
    /**
     * Title:      ExpireMap
     * @version    V1.0
     * Description: 设置map过期时间
     */
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
     
    /**
     * 
     * @Description: 带有效期map
     * @param <K>
     * @param <V>
     */
    public class ExpiryMap<K, V> extends HashMap<K, V> {
     
        private static final long serialVersionUID = 1L;
     
        /**
         * 过期时间设置为3分钟,可以修改
         */
        private long EXPIRY = 1000 * 60 * 3;
     
        private HashMap<K, Long> expiryMap = new HashMap<>();
     
        public ExpiryMap() {
            super();
        }
     
        public ExpiryMap(long defaultExpiryTime) {
            this(1 << 4, defaultExpiryTime);
        }
     
        public ExpiryMap(int initialCapacity, long defaultExpiryTime) {
            super(initialCapacity);
            this.EXPIRY = defaultExpiryTime;
        }
     
        public V put(K key, V value) {
            expiryMap.put(key, System.currentTimeMillis() + EXPIRY);
            return super.put(key, value);
        }
     
        public boolean containsKey(Object key) {
            return !checkExpiry(key, true) && super.containsKey(key);
        }
     
        /**
         * @param key
         * @param value
         * @param expiryTime
         *            键值对有效期 毫秒
         * @return
         */
        public V put(K key, V value, long expiryTime) {
            expiryMap.put(key, System.currentTimeMillis() + expiryTime);
            return super.put(key, value);
        }
     
        public int size() {
            return entrySet().size();
        }
     
        public boolean isEmpty() {
            return entrySet().size() == 0;
        }
     
        public boolean containsValue(Object value) {
            if (value == null)
                return Boolean.FALSE;
            Set<java.util.Map.Entry<K, V>> set = super.entrySet();
            Iterator<java.util.Map.Entry<K, V>> iterator = set.iterator();
            while (iterator.hasNext()) {
                java.util.Map.Entry<K, V> entry = iterator.next();
                if (value.equals(entry.getValue())) {
                    if (checkExpiry(entry.getKey(), false)) {
                        iterator.remove();
                        return Boolean.FALSE;
                    } else
                        return Boolean.TRUE;
                }
            }
            return Boolean.FALSE;
        }
     
        public Collection<V> values() {
     
            Collection<V> values = super.values();
     
            if (values == null || values.size() < 1)
                return values;
     
            Iterator<V> iterator = values.iterator();
     
            while (iterator.hasNext()) {
                V next = iterator.next();
                if (!containsValue(next))
                    iterator.remove();
            }
            return values;
        }
     
        public V get(Object key) {
            if (key == null)
                return null;
            if (checkExpiry(key, true))
                return null;
            return super.get(key);
        }
     
        /**
         * 
         * @Description: 是否过期
         * @param key
         * @return null:不存在或key为null -1:过期 存在且没过期返回value 因为过期的不是实时删除,所以稍微有点作用
         */
        public Object isInvalid(Object key) {
            if (key == null)
                return null;
            if (!expiryMap.containsKey(key)) {
                return null;
            }
            long expiryTime = expiryMap.get(key);
     
            boolean flag = System.currentTimeMillis() > expiryTime;
     
            if (flag) {
                super.remove(key);
                expiryMap.remove(key);
                return -1;
            }
            return super.get(key);
        }
     
        public void putAll(Map<? extends K, ? extends V> m) {
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
                expiryMap.put(e.getKey(), System.currentTimeMillis() + EXPIRY);
            super.putAll(m);
        }
     
        public Set<Map.Entry<K, V>> entrySet() {
            Set<java.util.Map.Entry<K, V>> set = super.entrySet();
            Iterator<java.util.Map.Entry<K, V>> iterator = set.iterator();
            while (iterator.hasNext()) {
                java.util.Map.Entry<K, V> entry = iterator.next();
                if (checkExpiry(entry.getKey(), false))
                    iterator.remove();
            }
     
            return set;
        }
     
        /**
         * 
         * @Description: 是否过期
         * @param expiryTime
         *            true 过期
         * @param isRemoveSuper
         *            true super删除
         * @return
         */
        private boolean checkExpiry(Object key, boolean isRemoveSuper) {
     
            if (!expiryMap.containsKey(key)) {
                return Boolean.FALSE;
            }
            long expiryTime = expiryMap.get(key);
     
            boolean flag = System.currentTimeMillis() > expiryTime;
     
            if (flag) {
                if (isRemoveSuper)
                    super.remove(key);
                expiryMap.remove(key);
            }
            return flag;
        }
     
        public static void main(String[] args) throws InterruptedException {
     
            ExpiryMap<String, String> map = new ExpiryMap<>(10);
            map.put("test", "ankang");
            map.put("test1", "ankang");
            map.put("test2", "ankang", 3000);
            System.out.println("test1" + map.get("test"));
            Thread.sleep(1000);
            System.out.println("isInvalid:" + map.isInvalid("test"));
            System.out.println("size:" + map.size());
            System.out.println("size:" + ((HashMap<String, String>) map).size());
            for (Map.Entry<String, String> m : map.entrySet()) {
                System.out.println("isInvalid:" + map.isInvalid(m.getKey()));
                map.containsKey(m.getKey());
                System.out.println("key:" + m.getKey() + "     value:" + m.getValue());
            }
            System.out.println("test1" + map.get("test"));
     
        }
    }

     

    https://blog.csdn.net/WoddenFish/article/details/79991968

    展开全文
  • 带过期时间map

    2020-08-06 09:56:53
    带过期时间Map import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * <p> * Title: ExpireMap * </p> * *...
  • 线程安全,失效时间Map 具体使用按照自己的需要修改或调整,当然也可以直接使用 /** * 失效时间Map,线程安全 */ public class CacheMap<K,T> { private static CacheMap cacheMap = null; ...
  • 设置key的过期时间,超过时间后,将会自动删除该key。在Redis的术语中一个key的相关超时是不确定的。超时后只有对key执行DEL命令或者SET命令或者GETSET时才会清除。 这意味着,从概念上讲所有改变key的值的操作都会...
  • 一:设置过期时间redis有四种命令可以用于设置键的生存时间过期时间:EXPIRE <KEY> <TTL> : 将键的生存时间设为 ttl 秒 PEXPIRE <KEY> <TTL> :将键的生存时间设为 ttl 毫秒EXPIREAT <...
  • 本地有一些数据需要用到map存储,希望能够设置过期时间,用远程缓存redis、memcache的话可以实现,但是又觉得大材小用,毕竟仅仅是少量的数据。 ExpiringMap 实现了这个功能 ExpiringMap github 最新maven依赖 <!...
  • Java基础之可设置过期时间map

    千次阅读 2020-02-26 22:57:09
    Java基础之可设置过期时间map 一、技术背景 在实际的项目开发中,我们经常会使用到缓存中间件(如redis、MemCache等)来帮助我们提高系统的可用性和健壮性。 但是很多时候如果项目比较简单,就没有必要为了使用...
  • 今天看看作为内存数据库,Redis 是怎么存储数据的以及键是怎么过期的。阅读这篇文章你将会了解到:Redis 的数据库实现Redis 键过期的策略数据库的实现我们先看代码 server.h/redisServerstruct redisServer{ ... //...
  • 带过期功能的map

    千次阅读 2017-11-08 11:12:12
    1.自己定义 package com.aiggo.common.util; import java.util.Collection; import java.util.HashMap; import java.util.Iterator;...import java.util.Map; import java.util.Set; /** * * @Des
  • 可以设置过期时间的Java缓存Map

    千次阅读 2019-07-01 18:05:00
    前言  最近项目需求需要一个类似于redis可以设置过期时间...1.可设置Map中的Entry在一段时间后自动过期。 2.可设置Map最大容纳值,当到达Maximum size后,再次插入值会导致Map中的第一个值过期。 3.可添加监听事...
  • 使用guava过期map

    2021-02-12 20:51:34
    防止重复请求微信接口获取token,造成token请求次数超标,其实随便一个缓存都可以轻松解决,但是现有的环境中没有redis,没有memcahe,做一个这个小功能,不需要引入这些框架,就用guava的过期map就可以了,不要要是服务宕机...
  • 为了一个小功能,不想引入redis,于是搜了点资料手写一个带过期时间的HashMap。 话不多说,直接上代码。 import java.util.*; /** * @author zy * @Title ExpiryMap 可以设置key过期时间Map * @description ...
  • 这是我为同一要求所做的示例实现,并发性很好。可能对某人有用。import java.text....import java.util.Map;import java.util.concurrent.ConcurrentHashMap;/**** @author Vivekananthan M** @param * @param...
  • 可以设置过期时间map --ExpiringMap

    千次阅读 2019-11-20 09:53:08
    put 的时候 可以设置时间,... //为Map中单个元素设置过期时间 @Test public void test4() throws InterruptedException { ExpiringMap<String, String> map = ExpiringMap.builder().variableExpiratio...
  • 偶然间看到一篇关于超期删除key的map的文章,感觉很有意思,于是自己去实现了一下。 了解了一下redis中key的过期策略,发现主要有三种策略:一种是被动删除,即key过期之后,先不将其删除,当实际访问到的时候,...
  • // 缓存accessToken 和 过期时间map private Map<String, String> map = new HashMap<String, String>(); private AccessTokenSingleton() {} private static AccessTokenSingleton single = ...
  • 每条信息有自己的过期时间; 需要一次获取用户的所有信息; 已过期的信息不能被获取到; 类似的场景还有很多,例如:用户领取的任务、待领取的优惠券 由于条件2的限制,不能直接使用哈希表(哈希表内数据的过期时间...
  • 这样就不用每次使用都从数据库中查询,减小数据库访问压力,需要做到缓存的数据定时的将不常用的清理出去,但是这个项目没有使用redis等缓存中间件,所以就自己基于map实现一个超时时间map集合; 这个集合参考了...
  • 1 importjava.util.Iterator;2 importjava.util.concurrent.ConcurrentHashMap;3 importjava.util.concurrent.TimeUnit;45 importorg.slf4j.Logger;...78 /**9 * 实现延时过期MAP集合 支持自定义过期触...
  • 以java为例,使用自带的map或者guava实现的是本地缓存,最主要的特点是轻量以及快速,生命周期随着jvm的销毁而结束,并且在多实例的情况下,每个实例都需要各自保存一份缓存,缓存不具有一致性。使用redis或...
  • java有效期的map

    2019-08-19 14:55:11
    版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权...在日常工作中有很多场景需要一个类似于MC或者redis这种可以设置过期时间的K,V存储方式,但是使用MC或者redis又有点大材小用,最理想的就是希望map有这个功...
  • 项目中做了一个基于websocket的消息推送功能,客户端浏览器...Map可以存放用户和对应的消息,但是没办法对过期消息进行维护,于是自己写了一个缓存类,重写了Map的几个主要方法。 package com.util.cache; imp...
  • 有效期的Map

    2019-05-28 08:21:50
    package ... import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** * @param <K> * @param &l...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 72,894
精华内容 29,157
关键字:

带过期时间的map