精华内容
下载资源
问答
  • JAVA实现延时过期MAP 支持自定义过期触发事件
    2021-03-24 13:54:11

    1 importjava.util.Iterator;2 importjava.util.concurrent.ConcurrentHashMap;3 importjava.util.concurrent.TimeUnit;4

    5 importorg.slf4j.Logger;6 importorg.slf4j.LoggerFactory;7

    8 /**

    9 * 实现延时过期MAP集合 支持自定义过期触发事件10 *11 * @ClassName: BaseExpireMap12 * @Description: TODO13 *@author: wangs14 * @date: 2017-12-25 上午9:59:0415 *@param16 *@param17 */

    18 public abstract class BaseExpireMap{19 protected static final Logger logger = LoggerFactory.getLogger(BaseExpireMap.class);20 private long expTime = 0L;21 private TimeUnit unit = null;22 /**

    23 * 线程安全的map容器24 */

    25 ConcurrentHashMap expireMap = null;26 /**

    27 * 控制过期时间28 */

    29 ConcurrentHashMap delayMap = null;30

    31 /**

    32 * 将map提供给外部程序操作33 * @Title: getDataMap34 * @Description: TODO35 *@return

    36 *@return: ConcurrentHashMap37 */

    38 public ConcurrentHashMapgetDataMap(){39 return this.expireMap;40 }41

    42 public BaseExpireMap(longexpTime, TimeUnit unit) {43 expireMap = new ConcurrentHashMap();44 delayMap = new ConcurrentHashMap();45 this.expTime =expTime;46 this.unit =unit;47 //启动监听线程

    48 BaseExpireCheckTask task = newBaseExpireCheckTask(expireMap, delayMap) {49 @Override50 protected voidexpireEvent(K key,V val) {51 baseExpireEvent(key,val);52 }53 };54 task.setDaemon(false);55 task.start();56 }57

    58 /**

    59 * 过期事件 子类实现60 *61 * @Title: baseExpireEvent62 * @Description: TODO63 *@paramkey64 *@return: void65 */

    66 protected abstract voidbaseExpireEvent(K key,V val);67

    68 publicV put(K key, V val) {69 delayMap.put(key, getExpireTime());70 returnexpireMap.put(key, val);71 }72

    73 publicV remove(K key) {74 returnexpireMap.remove(key);75 }76

    77 publicV get(K key){78 returnexpireMap.get(key);79 }80

    81 privateLong getExpireTime() {82 return unit.toMillis(expTime) +System.currentTimeMillis();83 }84

    85 public static voidmain(String[] args) {86 System.out.println(TimeUnit.SECONDS.toMinutes(120));87 System.out.println(TimeUnit.MICROSECONDS.toMillis(120));88 System.out.println(TimeUnit.MILLISECONDS.toMillis(120));89 }90

    91 /**

    92 * 扫描线程 定期移除过期元素并触发过期事件93 *94 * @ClassName: BaseExpireCheckTask95 * @Description: TODO96 *@author: wangs97 * @date: 2017-12-25 上午9:59:1898 */

    99 private abstract class BaseExpireCheckTask extendsThread {100 ConcurrentHashMap delayMap = null;101 ConcurrentHashMap expireMap = null;102

    103 public BaseExpireCheckTask(ConcurrentHashMap expireMap, ConcurrentHashMapdelayMap) {104 this.delayMap =delayMap;105 this.expireMap =expireMap;106 }107

    108 protected abstract void expireEvent(K key,V val);109

    110 public voidrun() {111 Iterator it = null;112 K key = null;113 while (true) {114 if (delayMap != null && !delayMap.isEmpty()) {115 it =delayMap.keySet().iterator();116 while(it.hasNext()) {117 key =it.next();118 if (delayMap.get(key) <= System.currentTimeMillis()) {//元素超时119 //触发回调

    120 expireEvent(key,expireMap.get(key));121 //移除

    122 it.remove();123 expireMap.remove(key);124 delayMap.remove(key);125 }126 }127 }128 try{129 TimeUnit.MILLISECONDS.sleep(200);130 } catch(InterruptedException e) {131 logger.error(e.getMessage());132 }133 }134 }135 }136 }

    更多相关内容
  • 主要介绍了Java缓存Map设置过期时间实现解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 可以设置过期时间Java缓存Map

    千次阅读 2020-12-19 04:47:34
    23 /**4 * @Title: ExpiryMap 可以设置过期时间Map5 * @description ExpiryMap继承至HashMap 重写了所有对外的方法,对每个key值都设置了有效期6 * @Author: xx7 * @Version: 1.08 */9 public class ExpiryMap ...

    1 import java.util.*;2

    3 /**

    4 * @Title: ExpiryMap 可以设置过期时间的Map5 * @description ExpiryMap继承至HashMap 重写了所有对外的方法,对每个key值都设置了有效期6 * @Author: xx7 * @Version: 1.08 */

    9 public class ExpiryMap extends HashMap{10

    11 private static final long serialVersionUID = 1L;12

    13 /**

    14 * default expiry time 2s15 */

    16 private long EXPIRY = 1000 * 2;17

    18 private HashMap expiryMap = new HashMap<>();19

    20 /**缓存实例对象*/

    21 private volatile static ExpiryMapSameUrlMap;22

    23 /**

    24 * 采用单例模式获取实例25 *@return

    26 */

    27 public staticExpiryMap getInstance() {28 //第一次判空,提高效率

    29 if (null ==SameUrlMap) {30 //保证线程安全

    31 synchronized (ExpiryMap.class) {32 //第二次判空,保证单例对象的唯一性,防止第一次有多个线程进入第一个if判断

    33 if (null ==SameUrlMap) {34 SameUrlMap = new ExpiryMap<>();35 }36 }37 }38 returnSameUrlMap;39 }40

    41 publicExpiryMap(){42 super();43 }44

    45 public ExpiryMap(longdefaultExpiryTime){46 this(1 << 4, defaultExpiryTime);47 }48

    49 public ExpiryMap(int initialCapacity, longdefaultExpiryTime){50 super(initialCapacity);51 this.EXPIRY =defaultExpiryTime;52 }53

    54 @Override55 publicV put(K key, V value) {56 expiryMap.put(key, System.currentTimeMillis() +EXPIRY);57 return super.put(key, value);58 }59

    60 @Override61 public booleancontainsKey(Object key) {62 return !checkExpiry(key, true) && super.containsKey(key);63 }64 /**

    65 *@paramkey66 *@paramvalue67 *@paramexpiryTime 键值对有效期 毫秒68 *@return

    69 */

    70 public V put(K key, V value, longexpiryTime) {71 expiryMap.put(key, System.currentTimeMillis() +expiryTime);72 return super.put(key, value);73 }74

    75 @Override76 public intsize() {77 returnentrySet().size();78 }79

    80 @Override81 public booleanisEmpty() {82 return entrySet().size() == 0;83 }84

    85 @Override86 public booleancontainsValue(Object value) {87 if (value == null) {88 returnBoolean.FALSE;89 }90 Set> set = super.entrySet();91 Iterator> iterator =set.iterator();92 while(iterator.hasNext()) {93 java.util.Map.Entry entry =iterator.next();94 if(value.equals(entry.getValue())){95 if(checkExpiry(entry.getKey(), false)) {96 iterator.remove();97 returnBoolean.FALSE;98 }else{99 returnBoolean.TRUE;100 }101 }102 }103 returnBoolean.FALSE;104 }105

    106 @Override107 public Collectionvalues() {108

    109 Collection values = super.values();110

    111 if(values == null || values.size() < 1) {112 returnvalues;113 }114

    115 Iterator iterator =values.iterator();116

    117 while(iterator.hasNext()) {118 V next =iterator.next();119 if(!containsValue(next)) {120 iterator.remove();121 }122 }123 returnvalues;124 }125

    126 @Override127 publicV get(Object key) {128 if (key == null) {129 return null;130 }131 if(checkExpiry(key, true)) {132 return null;133 }134 return super.get(key);135 }136 /**

    137 *138 * @Description: 是否过期139 *@paramkey140 *@returnnull:不存在或key为null -1:过期 存在且没过期返回value 因为过期的不是实时删除,所以稍微有点作用141 */

    142 publicObject isInvalid(Object key) {143 if (key == null) {144 return null;145 }146 if(!expiryMap.containsKey(key)){147 return null;148 }149 long expiryTime =expiryMap.get(key);150

    151 boolean flag = System.currentTimeMillis() >expiryTime;152

    153 if(flag){154 super.remove(key);155 expiryMap.remove(key);156 return -1;157 }158 return super.get(key);159 }160

    161 @Override162 public void putAll(Map extends K, ? extends V>m) {163 for (Map.Entry extends K, ? extends V>e : m.entrySet()) {164 expiryMap.put(e.getKey(), System.currentTimeMillis() +EXPIRY);165 }166 super.putAll(m);167 }168

    169 @Override170 public Set>entrySet() {171 Set> set = super.entrySet();172 Iterator> iterator =set.iterator();173 while(iterator.hasNext()) {174 java.util.Map.Entry entry =iterator.next();175 if(checkExpiry(entry.getKey(), false)) {176 iterator.remove();177 }178 }179

    180 returnset;181 }182 /**

    183 *184 * @Description: 是否过期185 *@paramexpiryTime true 过期186 *@paramisRemoveSuper true super删除187 *@return

    188 */

    189 private boolean checkExpiry(Object key, booleanisRemoveSuper){190

    191 if(!expiryMap.containsKey(key)){192 returnBoolean.FALSE;193 }194 long expiryTime =expiryMap.get(key);195

    196 boolean flag = System.currentTimeMillis() >expiryTime;197

    198 if(flag){199 if(isRemoveSuper) {200 super.remove(key);201 }202 expiryMap.remove(key);203 }204 returnflag;205 }206

    207 public static void main(String[] args) throwsInterruptedException {208 ExpiryMap map = new ExpiryMap<>();209 map.put("test", "xxx");210 map.put("test2", "ankang", 5000);211 System.out.println("test==" + map.get("test"));212 Thread.sleep(3000);213 System.out.println("test==" + map.get("test"));214 System.out.println("test2==" + map.get("test2"));215 Thread.sleep(3000);216 System.out.println("test2==" + map.get("test2"));217 }218 }

    展开全文
  • Java基础之可设置过期时间map

    千次阅读 2020-02-26 22:57:09
    Java基础之可设置过期时间map 一、技术背景 在实际的项目开发中,我们经常会使用到缓存中间件(如redis、MemCache等)来帮助我们提高系统的可用性和健壮性。 但是很多时候如果项目比较简单,就没有必要为了使用...

    Java基础之可设置过期时间的map

    一、技术背景

    在实际的项目开发中,我们经常会使用到缓存中间件(如redis、MemCache等)来帮助我们提高系统的可用性和健壮性。

    但是很多时候如果项目比较简单,就没有必要为了使用缓存而专门引入Redis等等中间件来加重系统的复杂性。那么Java本身有没有好用的轻量级的缓存组件呢。

    答案当然是有喽,而且方法不止一种。常见的解决方法有:ExpiringMap、LoadingCache及基于HashMap的封装三种。

    二、技术效果

    • 实现缓存的常见功能,如过时删除策略
    • 热点数据预热

    三、ExpiringMap

    3.1 功能简介

    1. 可设置Map中的Entry在一段时间后自动过期。
    2. 可设置Map最大容纳值,当到达Maximum size后,再次插入值会导致Map中的第一个值过期。
    3. 可添加监听事件,在监听到Entry过期时调度监听函数。
    4. 可以设置懒加载,在调用get()方法时创建对象。

    3.2 源码

    github地址

    3.3 示例

    1. 添加依赖(Maven)
    <dependency> 
        <groupId>net.jodah</groupId> 
        <artifactId>expiringmap</artifactId> 
        <version>0.5.8</version> 
    </dependency> 
    
    1. 示例源码
    public class ExpiringMapApp {
    
    	public static void main(String[] args) {
    		// maxSize: 设置最大值,添加第11个entry时,会导致第1个立马过期(即使没到过期时间)
    		// expiration:设置每个key有效时间10s, 如果key不设置过期时间,key永久有效。
    		// variableExpiration: 允许更新过期时间值,如果不设置variableExpiration,不允许后面更改过期时间,一旦执行更改过期时间操作会抛异常UnsupportedOperationException
    		// policy:
    		//        CREATED: 只在put和replace方法清零过期时间
    		//        ACCESSED: 在CREATED策略基础上增加, 在还没过期时get方法清零过期时间。
    		//        清零过期时间也就是重置过期时间,重新计算过期时间.
    		ExpiringMap<String, String> map = ExpiringMap.builder()
    			.maxSize(10)
    			.expiration(10, TimeUnit.SECONDS)
    			.variableExpiration().expirationPolicy(ExpirationPolicy.CREATED).build();
    
    		map.put("token", "lkj2412lj1412412nmlkjl2n34l23n4");
    		map.put("name", "管理员", 20000, TimeUnit.SECONDS);
    
    		// 模拟线程等待...
    		try {
    			Thread.sleep(15000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("token ===> " + map.get("token"));
    		System.out.println("name ===> " + map.get("name"));
    
    		// 注意: 在创建map时,指定的那些参数如过期时间和过期策略都是全局的, 对map中添加的每一个entry都适用.
    		//        在put一个entry键值对时可以对当前entry 单独设置 过期时间、过期策略,只对当前这个entry有效.
    	}
    }
    
    

    运行结果

    token ===> null
    name ===> 管理员
    
    1. 注意
    • 在创建map时,指定的那些参数如过期时间和过期策略都是全局的, 对map中添加的每一个entry都适用。
    • 在put一个entry键值对时可以对当前entry 单独设置 过期时间、过期策略,只对当前这个entry有效.

    四、LoadingCache

    4.1 功能简介

    Google开源出来的一个线程安全的本地缓存解决方案。

    特点:提供缓存回收机制,监控缓存加载/命中情况,灵活强大的功能,简单易上手的api。

    4.2 示例

    1. 源码
    public class LoadingCacheApp {
    
    	public static void main(String[] args) throws Exception {
    		// maximumSize: 缓存池大小,在缓存项接近该大小时, Guava开始回收旧的缓存项
    		// expireAfterAccess: 设置时间对象没有被读/写访问则对象从内存中删除(在另外的线程里面不定期维护)
    		// removalListener: 移除监听器,缓存项被移除时会触发的钩子
    		// recordStats: 开启Guava Cache的统计功能
    		LoadingCache<String, String> cache = CacheBuilder.newBuilder()
    			.maximumSize(100)
    			.expireAfterAccess(10, TimeUnit.SECONDS)
    			.removalListener(new RemovalListener<String, String>() {
    				@Override
    				public void onRemoval(RemovalNotification<String, String> removalNotification) {
    					System.out.println("过时删除的钩子触发了... key ===> " + removalNotification.getKey());
    				}
    			})
    			.recordStats()
    			.build(new CacheLoader<String, String>() {
    				// 处理缓存键不存在缓存值时的处理逻辑
    				@Override
    				public String load(String key) throws Exception {
    					return "不存在的key";
    				}
    			});
    
    		cache.put("name", "小明");
    		cache.put("pwd", "112345");
    
    		// 模拟线程等待...
    		try {
    			Thread.sleep(15000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    
    		System.out.println("token ===> " + cache.get("name"));
    		System.out.println("name ===> " + cache.get("pwd"));
    	}
    }
    
    1. 运行结果
    过时删除的钩子触发了... key ===> name
    token ===> 不存在的key
    过时删除的钩子触发了... key ===> pwd
    name ===> 不存在的key
    

    4.3 移除机制

    guava做cache时候数据的移除分为被动移除主动移除两种。

    被动移除

    • 基于大小的移除:数量达到指定大小,会把不常用的键值移除
    • 基于时间的移除:expireAfterAccess(long, TimeUnit) 根据某个键值对最后一次访问之后多少时间后移除。expireAfterWrite(long, TimeUnit) 根据某个键值对被创建或值被替换后多少时间移除
    • 基于引用的移除:主要是基于java的垃圾回收机制,根据键或者值的引用关系决定移除

    主动移除

    • 单独移除:Cache.invalidate(key)
    • 批量移除:Cache.invalidateAll(keys)
    • 移除所有:Cache.invalidateAll()

    如果配置了移除监听器RemovalListener,则在所有移除的动作时会同步执行该listener下的逻辑。

    如需改成异步,使用:RemovalListeners.asynchronous(RemovalListener, Executor).

    4.4 其他

    • 在put操作之前,如果已经有该键值,会先触发removalListener移除监听器,再添加
    • 配置了expireAfterAccess和expireAfterWrite,但在指定时间后没有被移除。
    • 删除策略逻辑:

    CacheBuilder构建的缓存不会在特定时间自动执行清理和回收工作,也不会在某个缓存项过期后马上清理,它不会启动一个线程来进行缓存维护,因为首先线程相对较重,其次某些环境限制线程的创建。

    它会在写操作时顺带做少量的维护工作,或者偶尔在读操作时做。当然,也可以创建自己的维护线程,以固定的时间间隔调用Cache.cleanUp()。

    五、HashMap的封装

    我们可以参考上面两个工具包的思路,自己封装一个可以设置过时时间的HashMap来实现我们想要的效果。

    展开全文
  • java map 设置超时时间

    2022-02-23 11:36:35
    import java.util.Collection;...import java.util.Map; import java.util.Set; /** * 带有效期map 简单实现 实现了基本的方法 * *<hr> * @author Hanjidong * @date 2022年2月23日 上午10:59:...

    package com.sysware.require.util;

    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;

    /**
     * 带有效期map 简单实现 实现了基本的方法
     *
     *<hr>
     * @author Hanjidong
     * @date 2022年2月23日 上午10:59:18
     * @since 0.0.1
     */
    public class ExpiryMap<K, V> extends HashMap<K, V>{

        private static final long serialVersionUID = 1L;

        /**
         * default expiry time 2m
         */
        private long EXPIRY = 3000 ;

        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;
        }
        
        /**
         *<hr> 是否过期  expiryTime true 过期 isRemoveSuper true super删除
         * @date 2022年2月23日 上午10:59:56
         * @since 0.0.1
         * @param key
         * @param isRemoveSuper
         * @return
         * boolean
         */
        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", 5000);
            System.out.println(" 100  size:" + map.size());
            for (Map.Entry<String, String> m : map.entrySet()) {
                System.out.println("key:" + m.getKey() + "     value:" + m.getValue());
            }
            Thread.sleep(1000);
            System.out.println("1000 size:" + map.size());
            for (Map.Entry<String, String> m : map.entrySet()) {
                System.out.println("key:" + m.getKey() + "     value:" + m.getValue());
            }
            
        }
    }

    展开全文
  • 过期地图 用Java编写的带有过期时间设置的Expirable Map 样本 Map<Integer> map = new CacheMap(1000 * 5); map.put(1, "value"); 然后map.get(1)将在 5 分钟后过期
  • Redis的过期设置 Redis所有的数据结构都可以设置过期时间,比如hash,需要注意,只能对hash整体设置过期时间,无法对其中的单个field设置过期时间。若一个对象已经设置过期时间,但是待会你又修改了他,那么他的...
  • 一:设置过期时间redis有四种命令可以用于设置键的生存时间过期时间:EXPIRE <KEY> <TTL> : 将键的生存时间设为 ttl 秒 PEXPIRE <KEY> <TTL> :将键的生存时间设为 ttl 毫秒EXPIREAT <...
  • redis map 过期时间_redis 过期时间

    千次阅读 2020-11-20 13:43:58
    设置key的过期时间,超过时间后,将会自动删除该key。在Redis的术语中一个key的相关超时是不确定的。超时后只有对key执行DEL命令或者SET命令或者GETSET时才会清除。 这意味着,从概念上讲所有改变key的值的操作都会...
  • // 缓存accessToken 和 过期时间map private Map<String, String> map = new HashMap<String, String>(); private AccessTokenSingleton() {} private static AccessTokenSingleton single = ...
  • java实现带过期时间的缓存

    千次阅读 2021-02-28 16:19:07
    public LocalCache() { //使用默认的线程池,每5秒清除一次过期数据 //线程池和调用频率 最好是交给调用者去设置。 swapExpiredPool.scheduleWithFixedDelay( new SwapExpiredNodeWork(), 5, 5, TimeUnit.SECONDS);...
  • 这是我为同一要求所做的示例实现,并发性很好。可能对某人有用。import java.text....import java.util.Map;import java.util.concurrent.ConcurrentHashMap;/**** @author Vivekananthan M** @param * @param...
  • 今天看看作为内存数据库,Redis 是怎么存储数据的以及键是怎么过期的。阅读这篇文章你将会了解到:Redis 的数据库实现Redis 键过期的策略数据库的实现我们先看代码 server.h/redisServerstruct redisServer{ ... //...
  • 过期时间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:
  • 记录一下map数据存储redis,设置过期时间,直接存储直接获取,不经过转数据格式 RedisTemplate.opsForHash().putAll(key,value)存储Map数据 RedisTemplate.expire(key,时间,TimeUnit.SECONDS)设置redis的过期时间 ...
  • java Map定时过期

    千次阅读 2016-03-24 13:49:58
    package com.ltx.system.util; import java.util.Date; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Timer; import java.util.Tim
  • 使用guava过期map

    2021-02-12 20:51:34
    防止重复请求微信接口获取token,造成token请求次数超标,其实随便一个缓存都可以轻松解决,但是现有的环境中没有redis,没有memcahe,做一个这个小功能,不需要引入这些框架,就用guava的过期map就可以了,不要要是服务宕机...
  • 用来存储短暂对象的缓存类,实现Map接口,内部有一个定时器用来清除过期(30秒)的对象。 为避免创建过多线程,没有特殊要求请使用getDefault()方法来获取本类的实例。package com.zuidaima.modules.common.util;...
  • Java设置session超时(失效)的时间

    千次阅读 2021-02-28 17:04:57
    在一般系统登录后,都会设置一个当前session失效的时间,以确保在用户长时间不与服务器交互,自动退出登录,销毁session具体设置的方法有三种:1.在web容器中设置(以tomcat为例)在tomcat-7.0\conf\web.xml中设置,...
  • @Cacheable 设置缓存过期时间

    千次阅读 2021-04-02 16:11:03
    RedisCacheConfig 文件 @Configuration ... * 只需要讲注解上keyGenerator的值设置为simpleKeyGenerator即可 **/ @Bean public KeyGenerator simpleKeyGenerator() { return (o, method, objects) -> {
  • 获取AccessKey ID和SECRET的值,java代码中调接口需要 鼠标放到个人图像上选择AccessKey管理 选择开始使用子用户AccessKey 创建用户组 点击新创建的用户组名称进入下图页面,选择添加权限 添加下面两个权限 ...
  • 带有失效时间Map

    千次阅读 2019-07-20 15:08:40
    今天是一个周六还要上班的苦逼...于是想到写到内存里,由于数据表结构比较适合Map存储,于是想写到Map,但是由于新增的数据不是在一个服务里面,需要对这个Map设置失效时间,稍微提升一点数据的准确性。 这里展示...
  • 过期时间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;... * Description: 设置map过期时间 * </p> * * <
  • 源代码连接地址:https://github.com/yanwankun/yan-study/blob/dev/yan-utils/src/main/java/cn/yan/study/utils/cache/ConcurrentHashMapCacheUtils.java package cn.yan.study.utils.cache; import org.slf4j....
  • java方法设置超时时间

    千次阅读 2015-04-15 11:03:32
    但是后台服务很不给力,并发一大常常就挂了,长时间不给返回,导致我的程序也挂死在那里…… 那么能不能设置一段代码执行的超时时间呢?如果处理超时就忽略该错误继续向下执行。 可是在网上搜了大半天,找到的都是...
  • 1.可设置Map中的Entry在一段时间后自动过期。 2.可设置Map最大容纳值,当到达Maximum size后,再次插入值会导致Map中的第一个值过期。 3.可添加监听事件,在监听到Entry过期时调度监听函数。 4.可以设置懒加载,在...
  • JavaMap实现缓存功能

    2021-11-09 20:20:44
    JavaMap实现缓存功能0.码仙励志1.自定义缓存工具类2.测试类 0.码仙励志 你要做多大的事情,就该承受多大的压力。 1.自定义缓存工具类 import java.util.ArrayList; import java.util.List; import java.util.Map; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,321
精华内容 22,128
关键字:

javamap设置过期时间

java 订阅