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

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

[java] view plain copy

print?

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

缓存对象CacheEntity.Java为：

[html] view plain copy

print?

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

List缓存处理对象：

[java] view plain copy

print?

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

Timer方式

[java] view plain copy

print?

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

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

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

时间： 2024-11-23 19:30:37

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

ASP.NET缓存中Cache过期的三种策略

原文:ASP.NET缓存中Cache过期的三种策略 我们在页面上添加三个按钮并双击按钮创建事件处理方法,三个按钮使用不同的过期策略添加ASP.NET缓存. <asp:Button ID="btn_InsertNoExpirationCache" runat="server" Text="插入永不过期缓存"      OnClick="btn_InsertNoExpirationCache_Click" />   

简述java中抛出异常的两种方式

java编程中经常遇到异常,这时就需要利用java中的异常抛出机制,在java中提供了两种抛出异常的方法:try{}  catch() {}和throw. 一.抛出异常的两种方式 (1) 首先我们来看一下try()  catch(){}这种方式: ? 1 2 3 4 5 6 try{    i=9\0; } catch(exception e) {     system.out.println("除数不能为0"): } 该种方式是将待执行的代码放入try中,如果执行的代码发生异常就会被

Java开启线程的两种方式

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.ios培训..Net培训</a>.期待与您交流!------ Java开启线程的两种方式: 方式一:成为线程(Thread)的儿子,即继承Thread类简单代码如下:class Student extends Thread{Student(String name){super(name);}public

java中super 的两种用法

通过用 static 来定义方法或成员,为我们编程提供了某种便利,从某种程度上可以说它类似于 C 语言中的全局函数和全局变量.但是,并不是说有了这种便利,你便可以随处使用,如果那样的话,你便需要认真考虑一下自己是否在用面向对象的思想编程,自己的程序是否是面向对象的. 好了,现在开始讨论 this&super 这两个关键字的意义和用法. 在 Java 中, this 通常指当前对象, super 则指父类的.当你想要引用当前对象的某种东西,比如当前对象的某个方法,或当前对象的某个成员,你便可以利用

java 实现多线程的两种方式

一.问题引入 说到这两个方法就不得不说多线程,说到多线程就不得不提实现多线程的两种方式继承Thread类和实现Runable接口,下面先看这两种方式的区别. 二. Java中实现多线程的两种方式 1.  继承Thread类 /** * 使用Thread类模拟4个售票窗口共同卖100张火车票的程序,实际上是各卖100张 */ public class ThreadTest { public static void main(String[] args){ new MyThread().start(

对Java代码加密的两种方式，防止反编译

使用Virbox Protector对Java项目加密有两种方式,一种是对War包加密,一种是对Jar包加密.Virbox Protector支持这两种文件格式加密,可以加密用于解析class文件的java.exe,并且可以实现项目源码绑定制定设备,防止部署到客户服务器的项目被整体拷贝. 两种加密方式 War 包加密 当你的项目在没有完成竣工的时候,不适合使用 war 文件,因为你的类会由于调试之类的经常改,这样来回删除.创建 war 文件很不爽,最好是你的项目已经完成了,不改了,那么就打个 w

述java中抛出异常的两种方式

java编程中经常遇到异常,这时就需要利用java中的异常抛出机制,在java中提供了两种抛出异常的方法:try{}  catch() {}和throw. 一.抛出异常的两种方式 (1) 首先我们来看一下try()  catch(){}这种方式: ? 1 2 3 4 5 6 try{    i=9\0; } catch(exception e) {     system.out.println("除数不能为0"): } 该种方式是将待执行的代码放入try中,如果执行的代码发生异常就会被

java.util.Arrays.sort两种方式的排序（及文件读写练习）

import java.io.*; import java.util.*; public class SortTest{ public static void main(String args[]) throws IOException, ClassNotFoundException { FileReader InWord = new FileReader(new File("words.txt")); BufferedReader in = new BufferedReader(In

java中线程分两种，守护线程和用户线程。

java中线程分为两种类型:用户线程和守护线程. 通过Thread.setDaemon(false)设置为用户线程: 通过Thread.setDaemon(true)设置为守护线程. 如果不设置次属性,默认为用户线程. 区别:主线程结束后用户线程会继续运行,JVM存活:主线程结束后,如果没有用户线程,都是守护线程,则JVM结束. public class Mytest extends Thread { public void run() { for(int i=0;;i++){ try { Th