1. package com.cttc.cache.entity;
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;
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;
18.     public SimpleConcurrentMap(Map<K, V> map) {
19.         this.map = map;
20.         if (map == null) throw new NullPointerException();
21.     }
23.     public void clear() {
24.         w.lock();
25.         try {
26.             map.clear();
27.         } finally {
28.             w.unlock();
29.         }
30.     }
32.     public boolean containsKey(Object key) {
33.         r.lock();
34.         try {
35.             return map.containsKey(key);
36.         } finally {
37.             r.unlock();
38.         }
39.     }
41.     public boolean containsValue(Object value) {
42.         r.lock();
43.         try {
44.             return map.containsValue(value);
45.         } finally {
46.             r.unlock();
47.         }
48.     }
50.     public Set<java.util.Map.Entry<K, V>> entrySet() {
51.         throw new UnsupportedOperationException();
52.     }
54.     public V get(Object key) {
55.         r.lock();
56.         try {
57.             return map.get(key);
58.         } finally {
59.             r.unlock();
60.         }
61.     }
63.     public boolean isEmpty() {
64.         r.lock();
65.         try {
66.             return map.isEmpty();
67.         } finally {
68.             r.unlock();
69.         }
70.     }
72.     public Set<K> keySet() {
73.         r.lock();
74.         try {
75.             return new HashSet<K>(map.keySet());
76.         } finally {
77.             r.unlock();
78.         }
79.     }
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.     }
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.     }
99.     public V remove(Object key) {
100.         w.lock();
101.         try {
102.             return map.remove(key);
103.         } finally {
104.             w.unlock();
105.         }
106.     }
108.     public int size() {
109.         r.lock();
110.         try {
111.             return map.size();
112.         } finally {
113.             r.unlock();
114.         }
115.     }
117.     public Collection<V> values() {
118.         r.lock();
119.         try {
120.             return new ArrayList<V>(map.values());
121.         } finally {
122.             r.unlock();
123.         }
124.     }
126. }

1. package com.cttc.cache.entity;
3. import java.io.Serializable;
5. public class CacheEntity implements Serializable{
6.     private static final long serialVersionUID = -3971709196436977492L;
7.     private final int DEFUALT_VALIDITY_TIME = 20;//默认过期时间 20秒
9.     private String cacheKey;
10.     private Object cacheContext;
11.     private int validityTime;//有效期时长，单位：秒
12.     private long timeoutStamp;//过期时间戳
14.     private CacheEntity(){
15.         this.timeoutStamp = System.currentTimeMillis() + DEFUALT_VALIDITY_TIME * 1000;
16.         this.validityTime = DEFUALT_VALIDITY_TIME;
17.     }
19.     public CacheEntity(String cacheKey, Object cacheContext){
20.         this();
21.         this.cacheKey = cacheKey;
22.         this.cacheContext = cacheContext;
23.     }
25.     public CacheEntity(String cacheKey, Object cacheContext, long timeoutStamp){
26.         this(cacheKey, cacheContext);
27.         this.timeoutStamp = timeoutStamp;
28.     }
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.     }
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. }

1. package com.cttc.cache.handler;
3. import java.util.ArrayList;
4. import java.util.HashMap;
5. import java.util.List;
7. import com.cttc.cache.entity.CacheEntity;
8. import com.cttc.cache.entity.SimpleConcurrentMap;
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;
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.     }
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.     }
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.     }
54.     /**
55.      * 获取缓存对象
56.      * @param key
57.      * @return
58.      */
59.     public static synchronized CacheEntity getCache(String key){
60.         return map.get(key);
61.     }
63.     /**
64.      * 检查是否含有制定key的缓冲
65.      * @param key
66.      * @return
67.      */
68.     public static synchronized boolean isConcurrent(String key){
69.         return map.containsKey(key);
70.     }
72.     /**
73.      * 删除缓存
74.      * @param key
75.      */
76.     public static synchronized void removeCache(String key){
77.         map.remove(key);
78.     }
80.     /**
81.      * 获取缓存大小
82.      * @param key
83.      */
84.     public static int getCacheSize(){
85.         return map.size();
86.     }
88.     /**
89.      * 清除全部缓存
90.      */
91.     public static synchronized void clearCache(){
92.         tempList.clear();
93.         map.clear();
94.         System.out.println(“clear cache”);
95.     }
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.         }
108.         /**
109.          * 过期缓存的具体处理方法
110.          * @throws Exception
111.          */
112.         private void checkTime() throws Exception{
113.             //”开始处理过期 “;
114.             CacheEntity tce = null;
115.             long timoutTime = 1000L;
117.             //” 过期队列大小 : “+tempList.size());
118.             if(1 > tempList.size()){
119.                 System.out.println(“过期队列空，开始轮询”);
120.                 timoutTime = 1000L;
121.                 Thread.sleep(timoutTime);
122.                 return;
123.             }
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. }

1. package com.cttc.cache.handler;
3. import java.util.HashMap;
4. import java.util.Timer;
5. import java.util.TimerTask;
7. import com.cttc.cache.entity.CacheEntity;
8. import com.cttc.cache.entity.SimpleConcurrentMap;
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;
27.     static{
28.         timer = new Timer();
29.         map = new SimpleConcurrentMap<String, CacheEntity>(new HashMap<String, CacheEntity>(1<<18));
30.     }
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.     }
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.     }
53.     /**
54.      * 获取缓存对象
55.      * @param key
56.      * @return
57.      */
58.     public static synchronized CacheEntity getCache(String key){
59.         return map.get(key);
60.     }
62.     /**
63.      * 检查是否含有制定key的缓冲
64.      * @param key
65.      * @return
66.      */
67.     public static synchronized boolean isConcurrent(String key){
68.         return map.containsKey(key);
69.     }
71.     /**
72.      * 删除缓存
73.      * @param key
74.      */
75.     public static synchronized void removeCache(String key){
76.         map.remove(key);
77.     }
79.     /**
80.      * 获取缓存大小
81.      * @param key
82.      */
83.     public static int getCacheSize(){
84.         return map.size();
85.     }
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.     }
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 ;
112.         public TimeoutTimerTask(String key){
113.             this.ceKey = key;
114.         }
116.         @Override
117.         public void run() {
118.             CacheTimerHandler.removeCache(ceKey);
119.             System.out.println(“remove : “+ceKey);
120.         }
121.     }
122. }

本文链接地址: java local cache本地缓存的两种实现，一个基于list轮询一个基于timer定时http://www.hongyanliren.com/2014m12/27122.html

相关文章

• 微信小程序中引入iconfont阿里矢量图库
• 微信小程序之toast等弹框提示
• 微信小程序-中处理json数据 （从json数据中提取想要的值 将变量json字符串转成json对象）
• 微信小程序中的变量和作用域
• 小程序 data变量用法 全局变量
• 微信小程序用setData修改数组或对象中的一个属性值
• 微信小程序多层嵌套循环，二级数组遍历【key】
• fastJSON使用（一）——对象转换成json