自己实现一个内存缓存

最近了解了下缓存技术，主要分为内存缓存 和磁盘缓存，然后分布式里面有一些消息的推送，节点的一些处理。现在很多的用OSCache,EhCache 等等，资料很多，暂时就不多说了，我这里仅仅为了了解缓存框架的的知识，自己临时写一个缓存，后面可以实现AOP 和spring 结合。

实现功能：
1.数据都缓存到内存中
2.实现对每个元素Element的缓存时间进行控制
3.对每个缓存Cache 进行创建，以及销毁的管理
4.能对缓存存放个数进行管理
5.通过线程定时检查元素是否过期
6.可以定义缓存清除策略

实现思路：
1.Store 接口：定义常用的存取元素get,put的接口
2.AbstractStore:对接口基本方法进行实现
3.MemoryCache:对具体缓存的存取方法进行实现，并执行一定的逻辑控制
4.Cache:增加对缓存整体进行监听，销毁等操作
5.CacheManager：缓存管理器，负责管理缓存的容器

6.CacheConfiguration ：一些缓存的配置属性
7.CheckManager：一些检查缓存内容的策略方法
8.EvictionType：枚举清空策略
9.CacheListener：缓存的监听，每次创建缓存就启动，然后定时检查缓存元素是否过期
10.Element: 元素的单元

Java代码  

1. package com.cache;  
2.   
3. import java.util.Collection;  
4.   
5.   
6. public interface Store {  
7.     // 获得缓存名字  
8.     public String getName();  
9.     // 存放元素  
10.     public Element put(Element e);  
11.     public Collection<Element> putAll(Collection<Element> elements);  
12.     // 获取元素  
13.     public Element get(Object key);  
14.     // 清除元素  
15.     public void clear();  
16.     // 移除元素  
17.     public void remove(Object key);  
18.     public void removeAll(Object[] keys);  
19.     // 获得的元素长度  
20.     public Integer size();  
21. }  

Java代码  

1. package com.cache;  
2.   
3. import java.util.Map;  
4.   
5. /** 
6.  * 抽象类实现 
7.  */  
8. public abstract class AbstractStore implements Store{  
9.       
10.     protected  Map<Object, Element> map;  
11.       
12.     public AbstractStore(){}  
13.     public AbstractStore(Map<Object, Element> map){  
14.         this.map = map;  
15.     }  
16.       
17.     @Override  
18.     public Element get(Object key) {  
19.         Element e = map.get(key);  
20.         return e;  
21.     }  
22.       
23.     public Map<Object, Element> getAll(){  
24.         return map;  
25.     }  
26.       
27.     @Override  
28.     public void clear() {  
29.          map.clear();  
30.     }  
31.       
32.     @Override  
33.     public Element put(Element e) {  
34.         return map.put(e.getKey(), e);  
35.     }  
36.       
37.     @Override  
38.     public void remove(Object key) {  
39.         map.remove(key);  
40.     }  
41.   
42.     @Override  
43.     public Integer size() {  
44.         return map.size();  
45.     }  
46.       
47.     @Override  
48.     public void removeAll(Object[] keys) {  
49.         for(int i =0;i<keys.length;i++){  
50.             remove(keys[i]);  
51.         }  
52.     }  
53. }  

Java代码  

1. package com.cache;  
2.   
3. import java.util.Collection;  
4. import java.util.HashMap;  
5. import java.util.Map;  
6.   
7. /** 
8.  * 缓存的基本方法 
9.  */  
10. public class MemoryCache extends AbstractStore implements Store{  
11.       
12.     private final CacheConfiguration configure;  
13.     private final static Map<Object, Element> map = new HashMap<Object, Element>();  
14.     private final CheckManager checkManager;  
15.       
16.       
17.     // 暂时仅弄一个构造  
18.     public MemoryCache(CacheConfiguration configure){  
19.         super(map);  
20.         this.configure = configure;  
21.         this.checkManager = new CheckManager(configure, map);  
22.     }  
23.       
24.     @Override  
25.     public String getName() {  
26.         return configure.getCacheName();  
27.     }  
28.   
29.     @Override  
30.     public  Collection<Element>  putAll(Collection<Element> elements) {  
31.         if(elements == null){  
32.             throw new NullPointerException("elements can‘t be null");  
33.         }  
34.         check(elements.size());  
35.         for(Element e : elements){  
36.             putElementStatus(e);  
37.             super.put(e);  
38.         }  
39.         return elements;  
40.     }  
41.       
42.     @Override  
43.     public synchronized Element put(Element e) {  
44.         check(1);  
45.         putElementStatus(e);  
46.         return super.put(e);  
47.     }  
48.       
49.       
50.     // 使用一次之后刷新使用过期时间，以及使用次数  
51.     // 并检查该元素是否过期  
52.     public void changeElement(Element e){  
53.         e.addHitCount();  
54.         if(!configure.getEternal()){  
55.             e.refreshLastAccessTime();  
56.         }  
57.     }  
58.       
59.     // 如果eternal 为true，表示元素永不过期,默认忽略最小元素控制  
60.     public void putElementStatus(Element e){  
61.         if(!configure.getEternal() && ! e.getIsOpen()){  
62.             e.setTimeToIdle(configure.getTimeToIdleSeconds());  
63.             e.setTimeToLive(configure.getTimeToLiveSeconds());  
64.         }else{  
65.             e.setTimeToIdle(0);  
66.             e.setTimeToLive(0);  
67.         }  
68.     }  
69.       
70.       
71.     @Override  
72.     public  Element get(Object key) {  
73.         Element e = super.get(key);  
74.         if(e != null){  
75.             if(!e.isExpired()){  
76.                 changeElement(e);  
77.             }else{  
78.                 synchronized (this) {  
79.                     remove(e.getKey());  
80.                     e = null;  
81.                 }  
82.             }  
83.         }  
84.         return e;  
85.     }  
86.       
87.       
88.       
89.     // 检查元素 是否为空  
90.     public boolean checkElement(Element e){  
91.         if(e == null){  
92.             throw new NullPointerException("Element can‘t be  null ");  
93.         }  
94.         if(e.getKey() == null){  
95.             throw new NullPointerException("Element key can‘t be  null ");  
96.         }  
97.         return true;  
98.     }  
99.   
100.     @Override  
101.     public synchronized void removeAll(Object[] keys) {  
102.         super.removeAll(keys);  
103.     }  
104.       
105.     // 检查元素是否超过了  
106.     public void check(int checkSize){  
107.         if(checkSize <= 0){  
108.             return;  
109.         }  
110.         Object[] keys = checkManager.checkConfigure(checkSize);  
111.         if(keys !=null) {  
112.             removeAll(keys);  
113.         }  
114.     }  
115. }  

Java代码  

1. package com.cache;  
2.   
3. /** 
4.  * 这是对缓存 级的控制判断 
5.  */  
6. public class Cache extends MemoryCache{  
7.       
8.     private CacheConfiguration configure;  
9.     private   CacheListener listener;  
10.       
11.     public Cache(CacheConfiguration configure) {  
12.         super(configure);  
13.         this.configure = configure;  
14.         if(!configure.getEternal()  &&  configure.getIsNeedCacheCheckListener()){  
15.             listener = new CacheListener(this);  
16.             listener.start();  
17.         }  
18.     }  
19.     public CacheConfiguration getConfigure() {  
20.         return configure;  
21.     }  
22.       
23.     // 销毁  
24.     public void destory(){  
25.         try{  
26.             super.clear();  
27.             if(listener != null){  
28.                 listener.interrupt();  
29.                 listener.stop();  
30.                 listener = null;  
31.             }  
32.         }catch (Exception e) {  
33.         }  
34.           
35.     }  
36. }  

Java代码  

1. package com.cache;  
2.   
3. import java.util.HashMap;  
4. import java.util.Map;  
5.   
6. /** 
7.  * 缓存管理类 
8.  */  
9. public class CacheManager {  
10.     // 默认单例  
11.     private CacheManager(){}  
12.     private static class  Singleton{  
13.         private static CacheManager instance = new CacheManager();  
14.     }  
15.     public static CacheManager getInstance() {  
16.         return Singleton.instance;  
17.     }  
18.       
19.     public static Map<String, Cache> MAP_NAMES_CACHE = new HashMap<String, Cache>();  
20.       
21.     // 存放 取出 缓存对象  
22.     public Cache getCache(String CacheName){  
23.         Cache cache = MAP_NAMES_CACHE.get(CacheName);  
24.         return cache;  
25.     }  
26.       
27.     public void putCache(Cache cache){  
28.         if(cache != null  && !MAP_NAMES_CACHE.containsKey(cache.getName())){  
29.             MAP_NAMES_CACHE.put(cache.getName(), cache);  
30.         }  
31.     }  
32.       
33.     // 移除  
34.     public void remove(String cacheName){  
35.         Cache c = MAP_NAMES_CACHE.remove(cacheName);  
36.         c.destory();  
37.     }  
38.       
39.     // 关闭所有缓存  
40.     public void shutDown(){  
41.         removeAllCaches();  
42.         MAP_NAMES_CACHE.clear();  
43.     }  
44.       
45.     // 移除所有  
46.     public void removeAllCaches(){  
47.         String [] cacheNames = getCacheNames();  
48.         for(String cacheName : cacheNames){  
49.             remove(cacheName);  
50.         }  
51.     }  
52.       
53.     // 获得名字  
54.     public String[] getCacheNames(){  
55.         return MAP_NAMES_CACHE.keySet().toArray(new String[0]);  
56.     }  
57.       
58. }  

Java代码  

1. package com.cache;  
2. /** 
3.  *  
4.  * 这些属性来自于ehcache  
5.  * 属于缓存级别的 一些控制 
6.  */  
7. public class CacheConfiguration {  
8.     // 缓存的名字  
9.     private String cacheName;  
10.     // 是否需要缓存 循环检查  
11.     private Boolean isNeedCacheCheckListener = false;  
12.     public Boolean getIsNeedCacheCheckListener() {  
13.         return isNeedCacheCheckListener;  
14.     }  
15.     public void setIsNeedCacheCheckListener(Boolean isNeedCacheCheckListener) {  
16.         this.isNeedCacheCheckListener = isNeedCacheCheckListener;  
17.     }  
18.     // 内存最大缓存对象数  
19.     private Integer maxElementsInMemory;  
20.       
21.     // 缓存元素是否永久有效，一旦设置true ,失效时间 将不起作用,默认false  
22.     private Boolean eternal = false;  
23.       
24.     // 设置缓存在失效前的允许闲置时间。仅当缓存不是永久有效时使用(timeToLiveSeconds != 0)  
25.     // 可选属性，默认值是0，也就是可闲置时间无穷大。  
26.     private Integer timeToIdleSeconds = 0;  
27.       
28.     // 设置缓存长允许存活时间，最大时间介于创建时间和失效时间之间.  
29.     // 仅当缓存不是永久有效时使用，默认值是0，也就是缓存存活时间无穷大。  
30.     private Integer timeToLiveSeconds = 0;  
31.     // 对象检测线程运行的时间间隔。表示对象状态的线程多长时间运行一次  
32.     // 这里暂时用来对内存对象的检查  
33.     private Integer diskExpiryThreadIntervalSeconds = 120;  
34.       
35.     // 如果缓存满了，执行清空策略  
36.     // 可选FIFO,LFU 这里要用枚举类型  
37.     // FIFO ：先进先出  
38.     // LFU:最少使用,一直以来最少被使用的，缓存缓存有一个hit属性，清除hit最小的  
39.     // LRU:最近最少使用，缓存元素有个时间戳，当缓存容量满了，而又需要腾出新地方  
40.     // 来缓存的时候，那么现有的缓存缓存中时间戳离当前时间最远的缓存将被清除缓存  
41.     private String memoryStoreEvictionPolicy = EvictionType.LRU.name();  
42.       
43.       
44.     // 暂时未用  
45.     // 当缓存数量达到最大值时，允许将缓存写入到磁盘  
46.     private Boolean overflowToDisk = false;  
47.     // 磁盘中最大的缓存对象数，若是0表示无穷大  
48.     private Integer maxElementsOnDisk = 0;  
49.     // 是否在磁盘上持久化，默认false  
50.     private Boolean diskPersistent = false;  
51.   
52.     public CacheConfiguration() {  
53.     }  
54.     public CacheConfiguration(String cacheName,Integer maxElementsInMemory,  
55.             Boolean eternal,Integer timeToIdleSeconds,Integer timeToLiveSeconds,  
56.             Integer diskExpiryThreadIntervalSeconds) {  
57.         this.cacheName = cacheName;  
58.         this.maxElementsInMemory = maxElementsInMemory;  
59.         this.eternal = eternal;  
60.         this.timeToIdleSeconds = timeToIdleSeconds;  
61.         this.timeToLiveSeconds = timeToLiveSeconds;  
62.         this.diskExpiryThreadIntervalSeconds = diskExpiryThreadIntervalSeconds;  
63.     }  
64.       
65.     public String getCacheName() {  
66.         return cacheName;  
67.     }  
68.     public void setCacheName(String cacheName) {  
69.         this.cacheName = cacheName;  
70.     }  
71.     public Integer getMaxElementsInMemory() {  
72.         return maxElementsInMemory;  
73.     }  
74.     public void setMaxElementsInMemory(Integer maxElementsInMemory) {  
75.         this.maxElementsInMemory = maxElementsInMemory;  
76.     }  
77.     public Boolean getEternal() {  
78.         return eternal;  
79.     }  
80.     public void setEternal(Boolean eternal) {  
81.         this.eternal = eternal;  
82.     }  
83.     public Integer getTimeToIdleSeconds() {  
84.         return timeToIdleSeconds;  
85.     }  
86.     public void setTimeToIdleSeconds(Integer timeToIdleSeconds) {  
87.         this.timeToIdleSeconds = timeToIdleSeconds;  
88.     }  
89.     public Integer getTimeToLiveSeconds() {  
90.         return timeToLiveSeconds;  
91.     }  
92.     public void setTimeToLiveSeconds(Integer timeToLiveSeconds) {  
93.         this.timeToLiveSeconds = timeToLiveSeconds;  
94.     }  
95.     public Boolean getOverflowToDisk() {  
96.         return overflowToDisk;  
97.     }  
98.     public void setOverflowToDisk(Boolean overflowToDisk) {  
99.         this.overflowToDisk = overflowToDisk;  
100.     }  
101.     public Integer getMaxElementsOnDisk() {  
102.         return maxElementsOnDisk;  
103.     }  
104.     public void setMaxElementsOnDisk(Integer maxElementsOnDisk) {  
105.         this.maxElementsOnDisk = maxElementsOnDisk;  
106.     }  
107.     public Boolean getDiskPersistent() {  
108.         return diskPersistent;  
109.     }  
110.     public void setDiskPersistent(Boolean diskPersistent) {  
111.         this.diskPersistent = diskPersistent;  
112.     }  
113.     public Integer getDiskExpiryThreadIntervalSeconds() {  
114.         return diskExpiryThreadIntervalSeconds;  
115.     }  
116.     public void setDiskExpiryThreadIntervalSeconds(  
117.             Integer diskExpiryThreadIntervalSeconds) {  
118.         this.diskExpiryThreadIntervalSeconds = diskExpiryThreadIntervalSeconds;  
119.     }  
120.     public String getMemoryStoreEvictionPolicy() {  
121.         return memoryStoreEvictionPolicy;  
122.     }  
123.     public void setMemoryStoreEvictionPolicy(String memoryStoreEvictionPolicy) {  
124.         this.memoryStoreEvictionPolicy = memoryStoreEvictionPolicy;  
125.     }  
126.       
127.       
128.       
129. }  

Java代码  

1. package com.cache;  
2.   
3. import java.io.Serializable;  
4.   
5. /** 
6.  * 缓存元素，所对应的属性 
7.  */  
8. @SuppressWarnings("serial")  
9. public class Element implements Serializable {  
10.     static final long ONE_SECOND = 1000L;  
11.     private Object key;  
12.     private Object value;  
13.     // 使用次数  
14.     private volatile long hitCount = 0;  
15.     // 这些属性是单个元素的属性控制  
16.     // 是否使用单独元素控制  
17.     private Boolean isOpen = false;  
18.     // 从创建时间开始后，还能存活时间，0 表示一直存活，超时时间=timeToLive + CreationTime  
19.     private volatile int timeToLive = 0;  
20.     // 从最近即(min(CreationTime，LastAccessTime)) 后还剩余的时间  
21.     private volatile int timeToIdle = 0;  
22.     // 创建时间  
23.     private transient long creationTime;  
24.     // 最后一次使用的时间  
25.     private transient long lastAccessTime;  
26.     // 最后更新时间  
27.     private volatile long lastUpdateTime;  
28.     // 表示是否使用cache 级别的控制，还是元素级别的控制，这里暂时不用  
29.     private volatile boolean cacheDefaultLifespan = true;  
30.       
31.     public Element(final Object key, final Object value){  
32.         init(key,value);  
33.     }  
34.       
35.     public Element(final Object key, final Object value,Boolean isOpen){  
36.         init(key, value);  
37.         this.isOpen = isOpen;  
38.     }  
39.       
40.     private void init(final Object key, final Object value){  
41.         this.key = key;  
42.         this.value = value;  
43.         this.creationTime = System.currentTimeMillis();  
44.         this.lastAccessTime = System.currentTimeMillis();  
45.     }  
46.       
47.       
48.     public Object getKey() {  
49.         return key;  
50.     }  
51.     public void setKey(Object key) {  
52.         this.key = key;  
53.     }  
54.     public Object getValue() {  
55.         return value;  
56.     }  
57.     public long getHitCount() {  
58.         return hitCount;  
59.     }  
60.     public void setHitCount(long hitCount) {  
61.         this.hitCount = hitCount;  
62.     }  
63.     public void addHitCount(){  
64.         hitCount += 1;  
65.     }  
66.   
67.     public int getTimeToLive() {  
68.         return timeToLive;  
69.     }  
70.   
71.   
72.     public void setTimeToLive(int timeToLive) {  
73.         this.timeToLive = timeToLive;  
74.     }  
75.   
76.   
77.     public int getTimeToIdle() {  
78.         return timeToIdle;  
79.     }  
80.   
81.   
82.     public void setTimeToIdle(int timeToIdle) {  
83.         this.timeToIdle = timeToIdle;  
84.     }  
85.     public long getCreationTime() {  
86.         return creationTime;  
87.     }  
88.     public void setCreationTime(long creationTime) {  
89.         this.creationTime = creationTime;  
90.     }  
91.     public long getLastAccessTime() {  
92.         return lastAccessTime;  
93.     }  
94.       
95.     public void setLastAccessTime(long lastAccessTime) {  
96.         this.lastAccessTime = lastAccessTime;  
97.     }  
98.     public long getLastUpdateTime() {  
99.         return lastUpdateTime;  
100.     }  
101.     public void setLastUpdateTime(long lastUpdateTime) {  
102.         this.lastUpdateTime = lastUpdateTime;  
103.     }  
104.   
105.   
106.     public boolean isCacheDefaultLifespan() {  
107.         return cacheDefaultLifespan;  
108.     }  
109.   
110.   
111.     public void setCacheDefaultLifespan(boolean cacheDefaultLifespan) {  
112.         this.cacheDefaultLifespan = cacheDefaultLifespan;  
113.     }  
114.   
115.   
116.     public void setValue(Object value) {  
117.         this.value = value;  
118.     }  
119.       
120.       
121.   
122.      public Boolean getIsOpen() {  
123.         return isOpen;  
124.     }  
125.   
126.     public void setIsOpen(Boolean isOpen) {  
127.         this.isOpen = isOpen;  
128.     }  
129.   
130.     /** 
131.       * 判断元素 是否过期 
132.       * @return 
133.       */  
134.      public boolean isExpired() {  
135.             if (isEternal()) {  
136.                 return false;  
137.             }  
138.             // 获得过期时间  
139.             long expirationTime = getExpirationTime();  
140.             long now = System.currentTimeMillis();  
141.             return now > expirationTime;  
142.      }  
143.      // 是否是不会过期  
144.      public boolean isEternal() {  
145.             return (0 == timeToIdle) && (0 == timeToLive);  
146.      }  
147.        
148.      // 计算过期时间  
149.      public long getExpirationTime() {  
150.             if (isEternal()) {  
151.                 return Long.MAX_VALUE;  
152.             }  
153.             // 存活时间  
154.             long expirationTime = 0;  
155.             long ttlExpiry = creationTime + getTimeToLive() * ONE_SECOND;  
156.             // 到期时间  
157.             long mostRecentTime = Math.max(creationTime, lastAccessTime);  
158.             long ttiExpiry = mostRecentTime + getTimeToIdle() * ONE_SECOND;  
159.             // 如果仅仅设置了timeToLive，那么时间以 timeToLive的计算为准  
160.             if (getTimeToLive() != 0 && (getTimeToIdle() == 0 || lastAccessTime == 0)) {  
161.                 expirationTime = ttlExpiry;  
162.             } else if (getTimeToLive() == 0) {  
163.                 // 如果仅仅设置了 timeToIdle，那么时间以timeToIdle 的计算为准  
164.                 expirationTime = ttiExpiry;  
165.             } else {  
166.                 // 如果两种都设置了，那么取小的一个为准  
167.                 expirationTime = Math.min(ttlExpiry, ttiExpiry);  
168.             }  
169.             return expirationTime;  
170.         }  
171.        
172.      // 刷新最后一次使用时间  
173.      public void refreshLastAccessTime(){  
174.          lastAccessTime = System.currentTimeMillis();  
175.      }  
176.       
177. }  

Java代码  

1. package com.cache;  
2.   
3. import java.util.Iterator;  
4. import java.util.Map;  
5. /** 
6.  * 检查的的一些方式 
7.  * @author Administrator 
8.  * 
9.  */  
10. public class CheckManager {  
11.   
12.     protected CacheConfiguration configure;  
13.     protected Map<Object, Element> map;  
14.       
15.     public CheckManager(CacheConfiguration configure,Map<Object, Element> map) {  
16.         this.map = map;  
17.         this.configure = configure;  
18.     }  
19.       
20.     // 添加检查元素是否已经到达最大值，或者已经过期  
21.     public Object[]  checkConfigure(int elementSize){  
22.         int removeSize = map.size()+elementSize - configure.getMaxElementsInMemory();  
23.         // 判断缓存是否已满  
24.         if(removeSize > 0){  
25.             // 按规则删除元素，这里不写磁盘  
26.             if(!configure.getDiskPersistent()){  
27.                 return removeElementByEvictionType(removeSize);  
28.             }  
29.         }  
30.         return null;  
31.     }  
32.       
33.     // 根据方式移除  
34.     public Object[] removeElementByEvictionType(int removeSize){  
35.         if(configure.getMemoryStoreEvictionPolicy().equals(EvictionType.LRU.name())){  
36.             return removeElementByLRU(removeSize);  
37.         }  
38.         return null;  
39.     }  
40.       
41.       
42.       
43.     // 暂时默认根据最少使用次数进行删除  
44.     private Object[] removeElementByLRU(int removeSize){  
45.         Object keys[] = new Object[removeSize];  
46.         long hits[] = new long[removeSize];  
47.         Iterator<?> it = map.keySet().iterator();  
48.         // 找出hit值最小的 removeSize 个元素  
49.         int index = 0;  
50.         while(it.hasNext()){  
51.             Object key =  it.next();  
52.             Element e = map.get(key);  
53.             long hit = e.getHitCount();  
54.             if(index < removeSize){  
55.                 hits[index] = hit;  
56.                 keys[index] = key;  
57.                 index ++;  
58.             }else{  
59.                 long pos = getMinIndex(hits, hit);  
60.                 if(pos >= 0){  
61.                     keys[(int) pos] = key;  
62.                 }  
63.             }  
64.         }  
65.         return keys;  
66.     }  
67.       
68.     private long getMinIndex(long hits[],long hit){  
69.         long pos = -1;  
70.         for(int i = 0;i<hits.length;i++){  
71.             if(hits[i] > hit){  
72.                 hits[i] = hit;  
73.                 pos = i;;  
74.             }  
75.         }  
76.         return pos;  
77.     }  
78.   
79.       
80.       
81. }  

Java代码  

1. package com.cache;  
2. /** 
3.  * 几种删除策略 
4.  */  
5. public enum EvictionType {  
6.      LRU,LFU,FIFO  
7. }  

Java代码  

1. package com.cache;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5. import java.util.Map;  
6. import java.util.Map.Entry;  
7.   
8. /** 
9.  * 循环检查元素 
10.  * @author Administrator 
11.  * 
12.  */  
13. public class CacheListener extends Thread{  
14.       
15.     private Cache cache;  
16.       
17.     private volatile boolean stop = false;  
18.     private volatile long ONE_SECOND = 1000;  
19.       
20.     public boolean isStop() {  
21.         return stop;  
22.     }  
23.     public void setStop(boolean stop) {  
24.         this.stop = stop;  
25.     }  
26.     public CacheListener(Cache cache) {  
27.         this.cache = cache;  
28.     }  
29.       
30.     @Override  
31.     public void run() {  
32.         long time = cache.getConfigure().getDiskExpiryThreadIntervalSeconds();  
33.         try {  
34.             while(!stop){  
35.                 sleep(time*ONE_SECOND);  
36.                 threadCheckElement();  
37.             }  
38.         } catch (InterruptedException e1) {  
39.             e1.printStackTrace();  
40.         }  
41.     }  
42.       
43.     public void destory(){  
44.         ONE_SECOND = 0;  
45.         stop = true;  
46.     }  
47.       
48.       
49.     public void threadCheckElement(){  
50.         List<Object> keys = new ArrayList<Object>();  
51.         Map<Object, Element> map  = cache.getAll();  
52.         if(map != null && map.size() > 0){  
53.             for(Entry<Object, Element> e0: map.entrySet()){  
54.                 Element e = e0.getValue();  
55.                 if(e != null && e.isExpired()){  
56.                     keys.add(e0.getKey());  
57.                 }  
58.             }  
59.         }  
60.         cache.removeAll(keys.toArray());  
61.     }  
62.       
63.       
64.   
65. }  

Java代码  

1. package com.test;  
2.   
3. import com.cache.Cache;  
4. import com.cache.CacheConfiguration;  
5. import com.cache.CacheManager;  
6. import com.cache.Element;  
7.   
8.   
9.   
10. public class Test {  
11.   
12.     /** 
13.      * @param args 
14.      * @throws InterruptedException  
15.      */  
16.     public static void main(String[] args) throws InterruptedException {  
17.         CacheManager cm = CacheManager.getInstance();  
18.         Cache c1 = new Cache(getConfigure());  
19.         // 最大放5个  
20.         putTestE1(c1);  
21.         cm.putCache(c1);  
22.           
23.         // 只有2 的hit 值最小，因此超过了就被移除了 null  
24.         System.out.println(c1.get(2));  
25.         // 想存放6了，实际数据只有5个  
26.         System.out.println("总数:"+c1.size());  
27.         // 休息3秒，然后使用  
28.         Thread.sleep(1000*3);  
29.         System.out.println("刷新："+c1.get(1));  
30.         // 然后继续休息  
31.         Thread.sleep(1000*3);  
32.         System.out.println("使用着的元素："+c1.size());  
33.         Thread.sleep(1000*15);  
34.         System.out.println("时间太久，全部过期"+c1.size());  
35.           
36.         //cm.shutDown();  
37.           
38.     }  
39.       
40.     public static CacheConfiguration getConfigure(){  
41.         CacheConfiguration c = new CacheConfiguration();  
42.         c.setCacheName("Test1");  
43.         // 最多存放5个元素  
44.         c.setMaxElementsInMemory(5);  
45.         // 假设5秒不用就过期，这两个时间一般默认选小的一个执行，最长时间是 存活的总时间  
46.         c.setTimeToIdleSeconds(5);  
47.         // 假设最长能存活115秒  
48.         c.setTimeToLiveSeconds(115);  
49.         // 6秒 检查一次过期  
50.         c.setDiskExpiryThreadIntervalSeconds(6);  
51.         return c;  
52.     }  
53.       
54.     public static void putTestE1(Cache c1){  
55.         c1.put(new Element(1, 2));  
56.         c1.get(1);  
57.         c1.put(new Element(2, 2));  
58.         //c1.get(2);  
59.         c1.put(new Element(3, 2));  
60.         c1.get(3);  
61.         c1.put(new Element(4, 2));  
62.         c1.get(4);  
63.         c1.put(new Element(5, 2));  
64.         c1.get(5);  
65.         c1.put(new Element(6, 2));  
66.     }  
67.       
68.       
69.   
70. }  

小结：

         1.这里是看了一些Ehcache 的源码，加上自己的思路写的，仅做第一次尝试之用

         2.关于磁盘缓存 和 分布式 的东西这里是没有的,包括异常各种处理，这里都是没有的

         3.关于缓存管理，这里每个cache 都有一个线程，是需要改进的，比较消耗资源

         4.测试代码，我测试了一部分，会有遗漏的，留点有兴趣的去搞吧。

         5.有问题请多指点，代码，和ehcache 已经在里面的，可以参考。