A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 张胜格 中级黑马   /  2012-12-30 16:26  /  2088 人查看  /  7 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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

评分

参与人数 1黑马币 +1 收起 理由
刘芮铭 + 1

查看全部评分

7 个回复

倒序浏览
这问题更犀利。。。占个沙发,坐等高手 解释。。。
回复 使用道具 举报
我只知道有垃圾回收机制。。。。
回复 使用道具 举报
依稀记得,这玩意 是操作系统有提到,什么先进先出,最近最久未被使用,。。。。这些东西  ,感觉应该也会被用到这。。。具体的真不晓得,目前也不想晓得。
回复 使用道具 举报
说一下缓存的管理不是靠时间久来计算的,是靠最大不活动间隔计算的。先打个比方说明下缓存是什么,有一个空间复制了硬盘上的一些数据,这个空间假如在内存上,那么程序需要这些数据的时候,从这个空间比从硬盘快得多,这就是缓存机制。要弄懂缓存先要明确几点:
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. public class CacheMgr {
  3.         private static Map cacheMap = new HashMap();
  4.         private static Map cacheConfMap = new HashMap();

  5.         private CacheMgr() {
  6.         }

  7.         private static CacheMgr cm = null;

  8.         public static CacheMgr getInstance() {
  9.                 if (cm == null) {
  10.                         cm = new CacheMgr();
  11.                         Thread t = new ClearCache();
  12.                         t.start();
  13.                 }
  14.                 return cm;
  15.         }

  16.         /**  增加缓存
  17.          * @param key
  18.          * @param value
  19.          * @param ccm 缓存对象
  20.          * @return
  21.          */
  22.         public boolean addCache(Object key, Object value, CacheConfModel ccm) {
  23.                 boolean flag = false;
  24.                 cacheMap.put(key, value);
  25.                 cacheConfMap.put(key, ccm);
  26.                 System.out.println("now addcache==" + cacheMap.size());
  27.                 return true;
  28.         }

  29.         /** * 删除缓存 * @param key * @return */
  30.         public boolean removeCache(Object key) {
  31.                 cacheMap.remove(key);
  32.                 cacheConfMap.remove(key);
  33.                 System.out.println("now removeCache==" + cacheMap.size());
  34.                 return true;
  35.         }

  36.         /**
  37.          * 清除缓存的类
  38.          *
  39.          *
  40.          */
  41.         private static class ClearCache extends Thread {
  42.                 public void run() {
  43.                         while (true) {
  44.                                 Set tempSet = new HashSet();
  45.                                 Set set = cacheConfMap.keySet();
  46.                                 Iterator it = set.iterator();
  47.                                 while (it.hasNext()) {
  48.                                         Object key = it.next();
  49.                                         CacheConfModel ccm = (CacheConfModel) cacheConfMap.get(key);
  50.                                         // 比较是否需要清除
  51.                                         if (!ccm.isForever()) {
  52.                                                 if ((new Date().getTime() - ccm.getBeginTime()) >= ccm
  53.                                                                 .getDurableTime() * 60 * 1000) {
  54.                                                         // 可以清除,先记录下来
  55.                                                         tempSet.add(key);
  56.                                                 }
  57.                                         }
  58.                                 }
  59.                                 // 真正清除
  60.                                 Iterator tempIt = tempSet.iterator();
  61.                                 while (tempIt.hasNext()) {
  62.                                         Object key = tempIt.next();
  63.                                         cacheMap.remove(key);
  64.                                         cacheConfMap.remove(key);
  65.                                 }
  66.                                 System.out.println("now thread================>"
  67.                                                 + cacheMap.size());
  68.                                 // 休息
  69.                                 try {
  70.                                         Thread.sleep(60 * 1000L);
  71.                                 } catch (InterruptedException e) {
  72.                                         // TODO Auto-generated catch block
  73.                                         e.printStackTrace();
  74.                                 }
  75.                         }
  76.                 }
  77.         }
  78. }

  79. class CacheConfModel implements java.io.Serializable {
  80.         private long beginTime;
  81.         private boolean isForever = false;
  82.         private int durableTime;

  83.         public long getBeginTime() {
  84.                 return beginTime;
  85.         }

  86.         public void setBeginTime(long beginTime) {
  87.                 this.beginTime = beginTime;
  88.         }

  89.         public boolean isForever() {
  90.                 return isForever;
  91.         }

  92.         public void setForever(boolean isForever) {
  93.                 this.isForever = isForever;
  94.         }

  95.         public int getDurableTime() {
  96.                 return durableTime;
  97.         }

  98.         public void setDurableTime(int durableTime) {
  99.                 this.durableTime = durableTime;
  100.         }

  101. }
复制代码
回复 使用道具 举报
有个东东叫 最近最久未被使用的 算法 ,进程调度的,应该与缓存也有关系。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马