有新数据到来时，怎样将缓存中最久未使用的数据从缓存中清除掉？最好能给出原理和程序

这问题更犀利。。。占个沙发，坐等高手 解释。。。

我只知道有垃圾回收机制。。。。

依稀记得，这玩意 是操作系统有提到，什么先进先出，最近最久未被使用，。。。。这些东西  ，感觉应该也会被用到这。。。具体的真不晓得，目前也不想晓得。

说一下缓存的管理不是靠时间久来计算的，是靠最大不活动间隔计算的。先打个比方说明下缓存是什么，有一个空间复制了硬盘上的一些数据，这个空间假如在内存上，那么程序需要这些数据的时候，从这个空间比从硬盘快得多，这就是缓存机制。要弄懂缓存先要明确几点：
1、缓存区必须是公有的，对外一致的，所以它是单例
2、不同的程序调用缓存区前要对其进行判定里面的数据是否达到清除条件，即在getInstance()方法里要执行clearCache()方法
3、考虑到是公共区所以clearCache()方法必须是在一个线程类里，而这个类是单例类的内部类
4、相对的我们还需要一个往缓存区里加数据的方法，还有就是需要一个删除缓存的方法
5、数据在缓存区的标识就是时间和数据存在状态，所以需要另外一个实体类(CacheConfModel)来存放数据的录入时间(beginTime)和缓存允许存在的最大时间(durableTime)以及
     数据状态(isForever)一般默认是false
有了以上5点，简单的缓存机制就基本实现了，clearCache()方法控制清除数据的代码，我只写个简单的原理了：
if(!cacheConfModel.isForever()){
      if((new Date().getTime()-cacheConfModel.getBeginTime())>= cacheConfModel.getDurableTime()){
       //清除数据
      }

学习学习！！！！

1. import java.util.*;
   
2. 
   
3. public class CacheMgr {
   
4.         private static Map cacheMap = new HashMap();
   
5.         private static Map cacheConfMap = new HashMap();
   
6. 
   
7.         private CacheMgr() {
   
8.         }
   
9. 
   
10.         private static CacheMgr cm = null;
    
11. 
    
12.         public static CacheMgr getInstance() {
    
13.                 if (cm == null) {
    
14.                         cm = new CacheMgr();
    
15.                         Thread t = new ClearCache();
    
16.                         t.start();
    
17.                 }
    
18.                 return cm;
    
19.         }
    
20. 
    
21.         /**  增加缓存
    
22.          * @param key
    
23.          * @param value
    
24.          * @param ccm 缓存对象
    
25.          * @return
    
26.          */
    
27.         public boolean addCache(Object key, Object value, CacheConfModel ccm) {
    
28.                 boolean flag = false;
    
29.                 cacheMap.put(key, value);
    
30.                 cacheConfMap.put(key, ccm);
    
31.                 System.out.println("now addcache==" + cacheMap.size());
    
32.                 return true;
    
33.         }
    
34. 
    
35.         /** * 删除缓存 * @param key * @return */
    
36.         public boolean removeCache(Object key) {
    
37.                 cacheMap.remove(key);
    
38.                 cacheConfMap.remove(key);
    
39.                 System.out.println("now removeCache==" + cacheMap.size());
    
40.                 return true;
    
41.         }
    
42. 
    
43.         /**
    
44.          * 清除缓存的类
    
45.          *
    
46.          *
    
47.          */
    
48.         private static class ClearCache extends Thread {
    
49.                 public void run() {
    
50.                         while (true) {
    
51.                                 Set tempSet = new HashSet();
    
52.                                 Set set = cacheConfMap.keySet();
    
53.                                 Iterator it = set.iterator();
    
54.                                 while (it.hasNext()) {
    
55.                                         Object key = it.next();
    
56.                                         CacheConfModel ccm = (CacheConfModel) cacheConfMap.get(key);
    
57.                                         // 比较是否需要清除
    
58.                                         if (!ccm.isForever()) {
    
59.                                                 if ((new Date().getTime() - ccm.getBeginTime()) >= ccm
    
60.                                                                 .getDurableTime() * 60 * 1000) {
    
61.                                                         // 可以清除，先记录下来
    
62.                                                         tempSet.add(key);
    
63.                                                 }
    
64.                                         }
    
65.                                 }
    
66.                                 // 真正清除
    
67.                                 Iterator tempIt = tempSet.iterator();
    
68.                                 while (tempIt.hasNext()) {
    
69.                                         Object key = tempIt.next();
    
70.                                         cacheMap.remove(key);
    
71.                                         cacheConfMap.remove(key);
    
72.                                 }
    
73.                                 System.out.println("now thread================>"
    
74.                                                 + cacheMap.size());
    
75.                                 // 休息
    
76.                                 try {
    
77.                                         Thread.sleep(60 * 1000L);
    
78.                                 } catch (InterruptedException e) {
    
79.                                         // TODO Auto-generated catch block
    
80.                                         e.printStackTrace();
    
81.                                 }
    
82.                         }
    
83.                 }
    
84.         }
    
85. }
    
86. 
    
87. class CacheConfModel implements java.io.Serializable {
    
88.         private long beginTime;
    
89.         private boolean isForever = false;
    
90.         private int durableTime;
    
91. 
    
92.         public long getBeginTime() {
    
93.                 return beginTime;
    
94.         }
    
95. 
    
96.         public void setBeginTime(long beginTime) {
    
97.                 this.beginTime = beginTime;
    
98.         }
    
99. 
    
100.         public boolean isForever() {
     
101.                 return isForever;
     
102.         }
     
103. 
     
104.         public void setForever(boolean isForever) {
     
105.                 this.isForever = isForever;
     
106.         }
     
107. 
     
108.         public int getDurableTime() {
     
109.                 return durableTime;
     
110.         }
     
111. 
     
112.         public void setDurableTime(int durableTime) {
     
113.                 this.durableTime = durableTime;
     
114.         }
     
115. 
     
116. }
     

复制代码

有个东东叫 最近最久未被使用的 算法 ，进程调度的，应该与缓存也有关系。