首页 > 编程语言 > 详细

java cache过期策略两种实现，一个基于list轮询一个基于timer定时

时间：2016-05-21 17:17:35      阅读：880      评论：0      收藏：0      [点我收藏+]

       最近项目要引入缓存机制，但是不想引入分布式的缓存框架，所以自己就写了一个轻量级的缓存实现，有两个版本，一个是通过timer实现其超时过期处理，另外一个是通过list轮询。
       首先要了解下java1.6中的ConcurrentMap ，他是一个线程安全的Map实现，特别说明的是在没有特别需求的情况下可以用ConcurrentHashMap。我是想学习一下读写锁的应用，就自己实现了一个SimpleConcurrentHashMap.

[java] view plain copy
 
 print?
  1. package com.cttc.cache.entity;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5. import java.util.HashSet;  
  6. import java.util.Map;  
  7. import java.util.Set;  
  8. import java.util.concurrent.locks.Lock;  
  9. import java.util.concurrent.locks.ReadWriteLock;  
  10. import java.util.concurrent.locks.ReentrantReadWriteLock;  
  11.   
  12. public class SimpleConcurrentMap<K, V> implements Map<K, V> {  
  13.     final ReadWriteLock lock = new ReentrantReadWriteLock();  
  14.     final Lock r = lock.readLock();  
  15.     final Lock w = lock.writeLock();  
  16.     final Map<K, V> map;  
  17.       
  18.     public SimpleConcurrentMap(Map<K, V> map) {  
  19.         this.map = map;  
  20.         if (map == null) throw new NullPointerException();  
  21.     }  
  22.   
  23.     public void clear() {  
  24.         w.lock();  
  25.         try {  
  26.             map.clear();  
  27.         } finally {  
  28.             w.unlock();  
  29.         }  
  30.     }  
  31.   
  32.     public boolean containsKey(Object key) {  
  33.         r.lock();  
  34.         try {  
  35.             return map.containsKey(key);  
  36.         } finally {  
  37.             r.unlock();  
  38.         }  
  39.     }  
  40.   
  41.     public boolean containsValue(Object value) {  
  42.         r.lock();  
  43.         try {  
  44.             return map.containsValue(value);  
  45.         } finally {  
  46.             r.unlock();  
  47.         }  
  48.     }  
  49.   
  50.     public Set<java.util.Map.Entry<K, V>> entrySet() {  
  51.         throw new UnsupportedOperationException();  
  52.     }  
  53.   
  54.     public V get(Object key) {  
  55.         r.lock();  
  56.         try {  
  57.             return map.get(key);  
  58.         } finally {  
  59.             r.unlock();  
  60.         }  
  61.     }  
  62.   
  63.     public boolean isEmpty() {  
  64.         r.lock();  
  65.         try {  
  66.             return map.isEmpty();  
  67.         } finally {  
  68.             r.unlock();  
  69.         }  
  70.     }  
  71.   
  72.     public Set<K> keySet() {  
  73.         r.lock();  
  74.         try {  
  75.             return new HashSet<K>(map.keySet());  
  76.         } finally {  
  77.             r.unlock();  
  78.         }  
  79.     }  
  80.   
  81.     public V put(K key, V value) {  
  82.         w.lock();  
  83.         try {  
  84.             return map.put(key, value);  
  85.         } finally {  
  86.             w.unlock();  
  87.         }  
  88.     }  
  89.   
  90.     public void putAll(Map<? extends K, ? extends V> m) {  
  91.         w.lock();  
  92.         try {  
  93.             map.putAll(m);  
  94.         } finally {  
  95.             w.unlock();  
  96.         }  
  97.     }  
  98.   
  99.     public V remove(Object key) {  
  100.         w.lock();  
  101.         try {  
  102.             return map.remove(key);  
  103.         } finally {  
  104.             w.unlock();  
  105.         }  
  106.     }  
  107.   
  108.     public int size() {  
  109.         r.lock();  
  110.         try {  
  111.             return map.size();  
  112.         } finally {  
  113.             r.unlock();  
  114.         }  
  115.     }  
  116.   
  117.     public Collection<V> values() {  
  118.         r.lock();  
  119.         try {  
  120.             return new ArrayList<V>(map.values());  
  121.         } finally {  
  122.             r.unlock();  
  123.         }  
  124.     }  
  125.   
  126. }  


缓存对象CacheEntity.Java为：

[html] view plain copy
 
 print?
  1. package com.cttc.cache.entity;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. public class CacheEntity implements Serializable{  
  6.     private static final long serialVersionUID = -3971709196436977492L;  
  7.     private final int DEFUALT_VALIDITY_TIME = 20;//默认过期时间 20秒  
  8.       
  9.     private String cacheKey;  
  10.     private Object cacheContext;  
  11.     private int validityTime;//有效期时长，单位：秒  
  12.     private long timeoutStamp;//过期时间戳  
  13.       
  14.     private CacheEntity(){  
  15.         this.timeoutStamp = System.currentTimeMillis() + DEFUALT_VALIDITY_TIME * 1000;  
  16.         this.validityTime = DEFUALT_VALIDITY_TIME;  
  17.     }  
  18.       
  19.     public CacheEntity(String cacheKey, Object cacheContext){  
  20.         this();  
  21.         this.cacheKey = cacheKey;  
  22.         this.cacheContext = cacheContext;  
  23.     }  
  24.       
  25.     public CacheEntity(String cacheKey, Object cacheContext, long timeoutStamp){  
  26.         this(cacheKey, cacheContext);  
  27.         this.timeoutStamp = timeoutStamp;  
  28.     }  
  29.       
  30.     public CacheEntity(String cacheKey, Object cacheContext, int validityTime){  
  31.         this(cacheKey, cacheContext);  
  32.         this.validityTime = validityTime;  
  33.         this.timeoutStamp = System.currentTimeMillis() + validityTime * 1000;  
  34.     }  
  35.   
  36.     public String getCacheKey() {  
  37.         return cacheKey;  
  38.     }  
  39.     public void setCacheKey(String cacheKey) {  
  40.         this.cacheKey = cacheKey;  
  41.     }  
  42.     public Object getCacheContext() {  
  43.         return cacheContext;  
  44.     }  
  45.     public void setCacheContext(Object cacheContext) {  
  46.         this.cacheContext = cacheContext;  
  47.     }  
  48.     public long getTimeoutStamp() {  
  49.         return timeoutStamp;  
  50.     }  
  51.     public void setTimeoutStamp(long timeoutStamp) {  
  52.         this.timeoutStamp = timeoutStamp;  
  53.     }  
  54.     public int getValidityTime() {  
  55.         return validityTime;  
  56.     }  
  57.     public void setValidityTime(int validityTime) {  
  58.         this.validityTime = validityTime;  
  59.     }  
  60. }  


List缓存处理对象：

[java] view plain copy
 
 print?
  1. package com.cttc.cache.handler;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.HashMap;  
  5. import java.util.List;  
  6.   
  7. import com.cttc.cache.entity.CacheEntity;  
  8. import com.cttc.cache.entity.SimpleConcurrentMap;  
  9.   
  10. /** 
  11.  * @projName：WZServer 
  12.  * @className：CacheHandler 
  13.  * @description：缓存操作类，对缓存进行管理，采用处理队列，定时循环清理的方式 
  14.  * @creater：Administrator  
  15.  * @creatTime：2013年7月22日 上午9:18:54  
  16.  * @alter：Administrator 
  17.  * @alterTime：2013年7月22日 上午9:18:54   
  18.  * @remark： 
  19.  * @version  
  20.  */  
  21. public class CacheListHandler {  
  22.     private static final long SECOND_TIME = 1000;  
  23.     private static final SimpleConcurrentMap<String, CacheEntity> map;  
  24.     private static final List<CacheEntity> tempList;  
  25.       
  26.     static{  
  27.         tempList = new ArrayList<CacheEntity>();  
  28.         map = new SimpleConcurrentMap<String, CacheEntity>(new HashMap<String, CacheEntity>(1<<18));  
  29.         new Thread(new TimeoutTimerThread()).start();  
  30.     }  
  31.               
  32.     /** 
  33.      * 增加缓存对象 
  34.      * @param key 
  35.      * @param ce 
  36.      */  
  37.     public static void addCache(String key, CacheEntity ce){  
  38.         addCache(key, ce, ce.getValidityTime());  
  39.     }  
  40.       
  41.     /** 
  42.      * 增加缓存对象 
  43.      * @param key 
  44.      * @param ce 
  45.      * @param validityTime 有效时间 
  46.      */  
  47.     public static synchronized void addCache(String key, CacheEntity ce, int validityTime){  
  48.         ce.setTimeoutStamp(System.currentTimeMillis() + validityTime * SECOND_TIME);  
  49.         map.put(key, ce);  
  50.         //添加到过期处理队列  
  51.         tempList.add(ce);  
  52.     }  
  53.       
  54.     /** 
  55.      * 获取缓存对象 
  56.      * @param key 
  57.      * @return 
  58.      */  
  59.     public static synchronized CacheEntity getCache(String key){  
  60.         return map.get(key);  
  61.     }  
  62.       
  63.     /** 
  64.      * 检查是否含有制定key的缓冲 
  65.      * @param key 
  66.      * @return 
  67.      */  
  68.     public static synchronized boolean isConcurrent(String key){  
  69.         return map.containsKey(key);  
  70.     }  
  71.       
  72.     /** 
  73.      * 删除缓存 
  74.      * @param key 
  75.      */  
  76.     public static synchronized void removeCache(String key){  
  77.         map.remove(key);  
  78.     }  
  79.       
  80.     /** 
  81.      * 获取缓存大小 
  82.      * @param key 
  83.      */  
  84.     public static int getCacheSize(){  
  85.         return map.size();  
  86.     }  
  87.       
  88.     /** 
  89.      * 清除全部缓存 
  90.      */  
  91.     public static synchronized void clearCache(){  
  92.         tempList.clear();  
  93.         map.clear();  
  94.         System.out.println("clear cache");  
  95.     }  
  96.       
  97.     static class TimeoutTimerThread implements Runnable {  
  98.         public void run(){  
  99.             while(true){  
  100.                 try {  
  101.                     checkTime();  
  102.                 } catch (Exception e) {  
  103.                     e.printStackTrace();  
  104.                 }  
  105.             }  
  106.         }  
  107.           
  108.         /** 
  109.          * 过期缓存的具体处理方法 
  110.          * @throws Exception 
  111.          */  
  112.         private void checkTime() throws Exception{    
  113.             //"开始处理过期 ";  
  114.             CacheEntity tce = null;  
  115.             long timoutTime = 1000L;  
  116.               
  117.             //" 过期队列大小 : "+tempList.size());  
  118.             if(1 > tempList.size()){  
  119.                 System.out.println("过期队列空，开始轮询");  
  120.                 timoutTime = 1000L;  
  121.                 Thread.sleep(timoutTime);  
  122.                 return;  
  123.             }  
  124.               
  125.             tce = tempList.get(0);  
  126.             timoutTime = tce.getTimeoutStamp() - System.currentTimeMillis();  
  127.             //" 过期时间 : "+timoutTime);  
  128.             if(0 < timoutTime){  
  129.                 //设定过期时间  
  130.                 Thread.sleep(timoutTime);  
  131.                 return;  
  132.             }  
  133.             System.out.print(" 清除过期缓存 ： "+tce.getCacheKey());  
  134.             //清除过期缓存和删除对应的缓存队列  
  135.             tempList.remove(tce);  
  136.             removeCache(tce.getCacheKey());  
  137.         }  
  138.     }  
  139. }  


Timer方式

[java] view plain copy
 
 print?
  1. package com.cttc.cache.handler;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Timer;  
  5. import java.util.TimerTask;  
  6.   
  7. import com.cttc.cache.entity.CacheEntity;  
  8. import com.cttc.cache.entity.SimpleConcurrentMap;  
  9.   
  10. /** 
  11.  * @projName：WZServer 
  12.  * @className：CacheHandler 
  13.  * @description：缓存操作类，对缓存进行管理,清除方式采用Timer定时的方式 
  14.  * @creater：Administrator  
  15.  * @creatTime：2013年7月22日 上午9:18:54  
  16.  * @alter：Administrator 
  17.  * @alterTime：2013年7月22日 上午9:18:54   
  18.  * @remark： 
  19.  * @version  
  20.  */  
  21. public class CacheTimerHandler {  
  22.     private static final long SECOND_TIME = 1000;//默认过期时间 20秒  
  23.     private static final int DEFUALT_VALIDITY_TIME = 20;//默认过期时间 20秒  
  24.     private static final Timer timer ;  
  25.     private static final SimpleConcurrentMap<String, CacheEntity> map;  
  26.       
  27.     static{  
  28.         timer = new Timer();  
  29.         map = new SimpleConcurrentMap<String, CacheEntity>(new HashMap<String, CacheEntity>(1<<18));  
  30.     }  
  31.               
  32.     /** 
  33.      * 增加缓存对象 
  34.      * @param key 
  35.      * @param ce 
  36.      */  
  37.     public static void addCache(String key, CacheEntity ce){  
  38.         addCache(key, ce, DEFUALT_VALIDITY_TIME);  
  39.     }  
  40.       
  41.     /** 
  42.      * 增加缓存对象 
  43.      * @param key 
  44.      * @param ce 
  45.      * @param validityTime 有效时间 
  46.      */  
  47.     public static synchronized void addCache(String key, CacheEntity ce, int validityTime){  
  48.         map.put(key, ce);  
  49.         //添加过期定时  
  50.         timer.schedule(new TimeoutTimerTask(key), validityTime * SECOND_TIME);  
  51.     }  
  52.       
  53.     /** 
  54.      * 获取缓存对象 
  55.      * @param key 
  56.      * @return 
  57.      */  
  58.     public static synchronized CacheEntity getCache(String key){  
  59.         return map.get(key);  
  60.     }  
  61.       
  62.     /** 
  63.      * 检查是否含有制定key的缓冲 
  64.      * @param key 
  65.      * @return 
  66.      */  
  67.     public static synchronized boolean isConcurrent(String key){  
  68.         return map.containsKey(key);  
  69.     }  
  70.       
  71.     /** 
  72.      * 删除缓存 
  73.      * @param key 
  74.      */  
  75.     public static synchronized void removeCache(String key){  
  76.         map.remove(key);  
  77.     }  
  78.       
  79.     /** 
  80.      * 获取缓存大小 
  81.      * @param key 
  82.      */  
  83.     public static int getCacheSize(){  
  84.         return map.size();  
  85.     }  
  86.       
  87.     /** 
  88.      * 清除全部缓存 
  89.      */  
  90.     public static synchronized void clearCache(){  
  91.         if(null != timer){  
  92.             timer.cancel();  
  93.         }  
  94.         map.clear();  
  95.         System.out.println("clear cache");  
  96.     }  
  97.       
  98.     /** 
  99.      * @projName：WZServer 
  100.      * @className：TimeoutTimerTask 
  101.      * @description：清除超时缓存定时服务类 
  102.      * @creater：Administrator  
  103.      * @creatTime：2013年7月22日 上午9:34:39  
  104.      * @alter：Administrator 
  105.      * @alterTime：2013年7月22日 上午9:34:39   
  106.      * @remark： 
  107.      * @version  
  108.      */  
  109.     static class TimeoutTimerTask extends TimerTask{  
  110.         private String ceKey ;  
  111.           
  112.         public TimeoutTimerTask(String key){  
  113.             this.ceKey = key;  
  114.         }  
  115.   
  116.         @Override  
  117.         public void run() {  
  118.             CacheTimerHandler.removeCache(ceKey);  
  119.             System.out.println("remove : "+ceKey);  
  120.         }  
  121.     }  
  122. }  


timer方式有点是适用性更强，因为每个缓存的过期时间都可以独立配置的；ist只能适用于缓存时间都一样的线性过期。从性能开销方面，因为timer是与缓存对象数量成正比的，在缓存量很大的时候，在缓存时间内系统开销也随之提高；而list方式只要一个线程管理过期清理就可以了。



这里要感谢饭饭泛，从其微博学习到很多http://www.blogjava.net/xylz/archive/2010/07/14/326080.html

java cache过期策略两种实现，一个基于list轮询一个基于timer定时

原文：http://www.cnblogs.com/firstdream/p/5515090.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！