Java中LocalCache本地缓存实现代码

/**
 * 缓存元素
 *
 */
public class CacheElement {
 private Object key;
 private Object value;
 private long createTime;
 private long lifeTime;
 private int hitCount;

 public CacheElement() {
 }

 public CacheElement(Object key ,Object value) {
 this.key = key;
 this.value = value;
 this.createTime = System.currentTimeMillis();
 }
 
 public Object getKey() {
 return key;
 }

 public void setKey(Object key) {
 this.key = key;
 }

 public Object getValue() {
 hitCount++;
 return value;
 }

 public void setValue(Object value) {
 this.value = value;
 }

 public long getCreateTime() {
 return createTime;
 }

 public void setCreateTime(long createTime) {
 this.createTime = createTime;
 }

 public int getHitCount() {
 return hitCount;
 }

 public void setHitCount(int hitCount) {
 this.hitCount = hitCount;
 }

 public long getLifeTime() {
 return lifeTime;
 }

 public void setLifeTime(long lifeTime) {
 this.lifeTime = lifeTime;
 }
 
 public boolean isExpired() {
 boolean isExpired = System.currentTimeMillis() - getCreateTime() > getLifeTime();
 return isExpired;
 }

 /*
 * (non-Javadoc)
 * @see java.lang.Object#toString()
 */
 public String toString() {
 StringBuffer sb = new StringBuffer();
 sb.append("[ key=").append(key).append(", isExpired=").append(isExpired())
  .append(", lifeTime=").append(lifeTime).append(", createTime=").append(createTime)
  .append(", hitCount=").append(hitCount)
  .append(", value=").append(value).append(" ]");
 return sb.toString();
 }
 
 /*
 * (non-Javadoc)
 * @see java.lang.Object#hashCode()
 */
 public final int hashCode(){
 if(null == key){
  return "".hashCode();
 }
 return this.key.hashCode();
 }
 
 /*
 * (non-Javadoc)
 * @see java.lang.Object#equals(java.lang.Object)
 */
 public final boolean equals(Object object) {
 if ((object == null) || (!(object instanceof CacheElement))) {
  return false;
 }

 CacheElement element = (CacheElement) object;
 if ((this.key == null) || (element.getKey() == null)) {
  return false;
 }

 return this.key.equals(element.getKey());
 }
}

import java.util.LinkedHashMap;
import java.util.Set;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 实现 LRU策略的 LinkedHashMap
 *
 * @param 
 * @param 
 */
public class LRULinkedHashMap extends LinkedHashMap 
{ 
 protected static final long serialVersiOnUID= 2828675280716975892L;
 
 protected static final int DEFAULT_MAX_ENTRIES = 100;
 
 protected final int initialCapacity; 
 protected final int maxCapacity; 
 protected boolean enableRemoveEldestEntry = true;//是否允许自动移除比较旧的元素(添加元素时)
 
 protected static final float DEFAULT_LOAD_FACTOR = 0.8f; 
 protected final Lock lock = new ReentrantLock(); 

  public LRULinkedHashMap(int initialCapacity) 
  { 
   this(initialCapacity, DEFAULT_MAX_ENTRIES);
  }
  
  public LRULinkedHashMap(int initialCapacity ,int maxCapacity) 
  { 
   //set accessOrder=true, LRU
    super(initialCapacity, DEFAULT_LOAD_FACTOR, true); 
    
    this.initialCapacity = initialCapacity; 
    this.maxCapacity = maxCapacity; 
  }

  /*
   *  (non-Javadoc)
   * @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)
   */
  protected boolean removeEldestEntry(java.util.Map.Entry eldest) 
  { 
    return enableRemoveEldestEntry && ( size() > maxCapacity );
  } 

 /*
 *  (non-Javadoc)
 * @see java.util.LinkedHashMap#get(java.lang.Object)
 */
  public V get(Object key) 
  { 
    try { 
      lock.lock(); 
      return super.get(key); 
    } 
    finally { 
      lock.unlock(); 
    } 
  } 

  /*
   *  (non-Javadoc)
   * @see java.util.HashMap#put(java.lang.Object, java.lang.Object)
   */
  public V put(K key, V value) 
  { 
    try { 
      lock.lock(); 
      return super.put(key, value); 
    } 
    finally { 
      lock.unlock(); 
    } 
  } 
  
  /*
   * (non-Javadoc)
   * @see java.util.HashMap#remove(java.lang.Object)
   */
  public V remove(Object key) {
    try { 
      lock.lock();
      return super.remove(key);
    } 
    finally { 
      lock.unlock(); 
    }
  }
  
  /*
   * (non-Javadoc)
   * @see java.util.LinkedHashMap#clear()
   */
  public void clear() {
   try { 
       lock.lock();
       super.clear();
     } 
     finally { 
       lock.unlock();
     }
  }
  
  /*
   * (non-Javadoc)
   * @see java.util.HashMap#keySet()
   */
  public Set keySet() {
   try { 
      lock.lock();
      return super.keySet();
    } 
    finally { 
      lock.unlock();
    }
  }
  
  public boolean isEnableRemoveEldestEntry() {
 return enableRemoveEldestEntry;
 }
 public void setEnableRemoveEldestEntry(boolean enableRemoveEldestEntry) {
 this.enableRemoveEldestEntry = enableRemoveEldestEntry;
 }
 public int getInitialCapacity() {
 return initialCapacity;
 }
 public int getMaxCapacity() {
 return maxCapacity;
 }
} 

/**
 * 缓存接口
 *
 */
public interface Cache {
 
 /**
 * 获取缓存
 * @param key
 * @return
 */
 public  T getCache(Object key);
 
 /**
 * 缓存对象
 * @param key
 * @param value
 * @param milliSecond 缓存生命周期(毫秒)
 */
 public void putCache(Object key, Object value ,Long milliSecond);
 
 /**
 * 缓存容器中是否包含 key 
 * @param key
 * @return
 */
 public boolean containsKey(Object key);
 
 /**
 * 缓存列表大小
 * @return
 */
 public int getSize();
 
 /**
 * 是否启用缓存
 */
 public boolean isEnabled();
 /**
 * 启用 或 停止
 * @param enable
 */
 public void setEnabled(boolean enabled);
 
 /**
 * 移除所有缓存
 */
 public void invalidateCaches();
 
 /**
 * 移除 指定key缓存
 * @param key
 */
 public void invalidateCache(Object key);
}

import java.util.Date;
import java.util.Iterator;
import java.util.Random;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 本地缓存组件
 */
public class LocalCache implements Cache{
 private Logger logger = LoggerFactory.getLogger(this.getClass());
 
 private LRULinkedHashMap cacheMap;
 
 protected boolean initFlag = false;//初始化标识
 
 protected final long defaultLifeTime = 5 * 60 * 1000;//5分钟
 protected boolean warnLOngerLifeTime= false;
 
 protected final int DEFAULT_INITIAL_CAPACITY = 100;
 protected final int DEFAULT_MAX_CAPACITY = 100000;
 
 protected int initialCapacity = DEFAULT_INITIAL_CAPACITY;//初始化缓存容量
 protected int maxCapacity = DEFAULT_MAX_CAPACITY;//最大缓存容量
 protected int timeout = 20;//存取缓存操作响应超时时间(毫秒数)
 
 private boolean enabled = true;
 
 private Thread gcThread = null;
 private String lastGCInfo = null;//最后一次GC清理信息{ size, removeCount, time ,nowTime}
 private boolean logGCDetail = false;//记录gc清理细节
 
 private boolean enableGC = true;//是否允许清理的缓存(添加元素时)
 private int gcMode = 0;//清理过期元素模式 { 0=迭代模式 ; 1=随机模式 }
 private int gcIntervalTime = 2 * 60 * 1000;//间隔时间(分钟)
 
 private boolean iterateScanAll = true;//是否迭代扫描全部
 private float gcFactor = 0.5F;//清理百分比
 private int maxIterateSize = DEFAULT_MAX_CAPACITY/2;//迭代模式下一次最大迭代数量
 private volatile int iterateLastIndex = 0;//最后迭代下标
 private int maxRandomTimes = 100;//随机模式下最大随机次数
 
 
 protected final static Random random = new Random();
 private static LocalCache instance = new LocalCache();
 public static LocalCache getInstance() {
 return instance;
 }
 private LocalCache(){
 this.init();
 }
 
 protected synchronized void init() {
 if(initFlag){
  logger.warn("init repeat.");
  return ;
 }
 
 this.initCache();
 
 this.startGCDaemonThread();
 
 initFlag = true;
 
 if(logger.isInfoEnabled()){
  logger.info("init -- OK");
 }
 }
 
 private void startGCDaemonThread(){
 if(initFlag){
  return ;
 }
 
 this.maxIterateSize = maxCapacity /2;
 try{
  this.gcThread = new Thread() {
  public void run() {
   logger.info("[" + (Thread.currentThread().getName()) + "]start...");
   //sleep
   try {
   Thread.sleep(getGcIntervalTime() <30000 &＃63; 30000 : getGcIntervalTime());
   } catch (Exception e) {
   e.printStackTrace();
   }
   while( true ){
   //gc
   gc();
   //sleep
   try {
    Thread.sleep(getGcIntervalTime() <30000 &＃63; 30000 : getGcIntervalTime());
   } catch (Exception e) {
    e.printStackTrace();
   }
   }
  }
  };
  this.gcThread.setName("localCache-gcThread");
  this.gcThread.setDaemon(true);
  this.gcThread.start();
  
  if(logger.isInfoEnabled()){
  logger.info("startGCDaemonThread -- OK");
  }
 }catch(Exception e){
  logger.error("[localCache gc]DaemonThread -- error: " + e.getMessage(), e);
 }
 }
 
 private void initCache(){
 if(initFlag){
  return ;
 }
 
 initialCapacity = (initialCapacity <= 0 &＃63; DEFAULT_INITIAL_CAPACITY : initialCapacity);
 maxCapacity = (maxCapacity  T getCache(Object key) {
 if(!isEnabled()){
  return null;
 }
 long st = System.currentTimeMillis();
 
 T objValue = null;
 CacheElement cacheObj = cacheMap.get(key);
 
 if (isExpiredCache(cacheObj)) {
  cacheMap.remove(key);
 }else {
  objValue = (T) (cacheObj == null &＃63; null : cacheObj.getValue());
 }
 
 long et = System.currentTimeMillis();
 if((et - st)>timeout){
  if(this.logger.isWarnEnabled()){
  this.logger.warn("getCache_timeout_" + (et - st) + "_[" + key + "]");
  }
 }
 
 if(logger.isDebugEnabled()){
  String message = ("get( " + key + ") return: " + objValue);
  logger.debug(message);
 }
 return objValue;
 }

 /*
 * (non-Javadoc)
 */
 public void putCache(Object key, Object value ,Long lifeTime) {
 if(!isEnabled()){
  return;
 }
 Long st = System.currentTimeMillis();
 
 lifeTime = (null == lifeTime &＃63; defaultLifeTime : lifeTime);
 CacheElement cacheObj = new CacheElement();
 cacheObj.setCreateTime(System.currentTimeMillis());
 cacheObj.setLifeTime(lifeTime);
 cacheObj.setValue(value);
 cacheObj.setKey(key);
 cacheMap.put(key, cacheObj);
 
 long et = System.currentTimeMillis();
 if((et - st)>timeout){
  if(this.logger.isWarnEnabled()){
  this.logger.warn("putCache_timeout_" + (et - st) + "_[" + key + "]");
  }
 }
 
 if(logger.isDebugEnabled()){
  String message = ("putCache( " + cacheObj + " ) , 耗时 " + (et - st) + "(毫秒).");
  logger.debug(message);
 }
 if(lifeTime > defaultLifeTime && this.isWarnLongerLifeTime()){
  if(logger.isWarnEnabled()){
  String message = ("LifeTime[" + (lifeTime/1000) + "秒] too long for putCache(" + cacheObj + ")");
  logger.warn(message);
  }
 }
 }
 
 /**
 * key 是否过期
 * @param key
 * @return
 */
 protected boolean isExpiredKey(Object key) {
 CacheElement cacheObj = cacheMap.get(key);
 return this.isExpiredCache(cacheObj);
 }
 
 /**
 * cacheObj 是否过期
 * @param key
 * @return
 */
 protected boolean isExpiredCache(CacheElement cacheObj) {
 if (cacheObj == null) {
  return false;
 }
 return cacheObj.isExpired();
 }
 
 /*
 * (non-Javadoc)
 */
 public void invalidateCaches(){
 try{
  cacheMap.clear();
 }catch(Exception e){
  e.printStackTrace();
 }
 }
 
 /*
 * (non-Javadoc)
 */
 public void invalidateCache(Object key){
 try{
  cacheMap.remove(key);
 }catch(Exception e){
  e.printStackTrace();
 }
 }
 
 /*
 * (non-Javadoc)
 */
 public boolean containsKey(Object key) {
 return cacheMap.containsKey(key);
 }

 /*
 * (non-Javadoc)
 */
 public int getSize() {
 return cacheMap.size();
 }

 /*
 * (non-Javadoc)
 */
 public Iterator getKeyIterator() {
 return cacheMap.keySet().iterator();
 }

 /*
 * (non-Javadoc)
 */
 public boolean isEnabled() {
 return this.enabled;
 }

 /*
 * (non-Javadoc)
 */
 public void setEnabled(boolean enabled) {
 this.enabled = enabled;
 if(!this.enabled){
  //清理缓存
  this.invalidateCaches();
 }
 }
 
  /**
   * 清理过期缓存
   */
  protected synchronized boolean gc(){
   
   if(!isEnableGC()){
   return false;
   }
   
   try{
   
   iterateRemoveExpiredCache();
   
 }catch(Exception e){
  logger.error("gc() has error: " + e.getMessage(), e);
 }
   return true;
  }
  
 /**
 * 迭代模式 - 移除过期的 key
 * @param exceptKey
 */
 private void iterateRemoveExpiredCache(){
 long startTime = System.currentTimeMillis(); 
 
 int size = cacheMap.size();
 if(size ==0){
  return;
 }
 
 int keyCount = 0;
 int removedCount = 0 ;
 
 int startIndex = 0;
 int endIndex = 0;
 
 try{
  Object [] keys = cacheMap.keySet().toArray();
  keyCount = keys.length;
  int maxIndex = keyCount -1 ;
  
  //初始化扫描下标
  if(iterateScanAll){
  startIndex = 0;
  endIndex = maxIndex;
  }else {
  int gcThreshold = this.getGcThreshold();
  int iterateLen = gcThreshold > this.maxIterateSize &＃63; this.maxIterateSize : gcThreshold;
  
  startIndex = this.iterateLastIndex;
  startIndex = ( (startIndex <0 || startIndex > maxIndex) &＃63; 0 : startIndex );
  endIndex = (startIndex + iterateLen);
  endIndex = (endIndex > maxIndex &＃63; maxIndex : endIndex);
  }
  
  //迭代清理
  boolean flag = false;
  for(int i=startIndex; i<= endIndex; i++){
  flag = this.removeExpiredKey(keys[i]);
  if(flag){
   removedCount++;
  }
  }
  
  this.iterateLastIndex = endIndex;
  keys = null;
  
 }catch(Exception e){
  logger.error("iterateRemoveExpiredCache -- 移除过期的 key时出现异常: " + e.getMessage(), e);
 }
 
 long endTime = System.currentTimeMillis();
 
 StringBuffer sb = new StringBuffer();
 sb.append("iterateRemoveExpiredCache [ size: ").append(size).append(", keyCount: ").append(keyCount)
  .append(", startIndex: ").append(startIndex).append(", endIndex: ").append(iterateLastIndex)
  .append(", removedCount: ").append(removedCount).append(", currentSize: ").append(this.cacheMap.size())
  .append(", timeConsuming: ").append(endTime - startTime).append(", nowTime: ").append(new Date())
  .append(" ]");
 this.lastGCInfo = sb.toString();
 
 if(logger.isInfoEnabled()){
  logger.info("iterateRemoveExpiredCache -- 清理结果 -- "+ lastGCInfo);
 }
 }
 
 /**
 * 随机模式 - 移除过期的 key
 */
 private void randomRemoveExpiredCache(){
 long startTime = System.currentTimeMillis(); 
 
 int size = cacheMap.size();
 if(size ==0){
  return;
 }
 
 int removedCount = 0 ;
 try{
  Object [] keys = cacheMap.keySet().toArray();
  int keyCount = keys.length;
  
  boolean removeFlag = false;
  
  int removeRandomTimes = this.getGcThreshold();
  
  removeRandomTimes = ( removeRandomTimes > this.getMaxRandomTimes() &＃63; this.getMaxRandomTimes() : removeRandomTimes );
  while(removeRandomTimes-- > 0){
  
  int index = random.nextInt(keyCount);
  boolean flag = this.removeExpiredKey(keys[index]);
  if(flag){
   removeFlag = true;
   removedCount ++;
  }
  }
  //尝试 移除 首尾元素
  if(!removeFlag){
   this.removeExpiredKey(keys[0]);
   this.removeExpiredKey(keys[keyCount-1]);
  }
  keys=null;
  
 }catch(Exception e){
      logger.error("randomRemoveExpiredCache -- 移除过期的 key时出现异常: " + e.getMessage(), e);
 }
 long endTime = System.currentTimeMillis();
 
 StringBuffer sb = new StringBuffer();
 sb.append("randomRemoveExpiredCache [ size: ").append(size).append(", removedCount: ").append(removedCount)
  .append(", currentSize: ").append(this.cacheMap.size()).append(", timeConsuming: ").append(endTime - startTime)
  .append(", nowTime: ").append(new Date())
  .append(" ]");
 this.lastGCInfo = sb.toString();
 
 if(logger.isInfoEnabled()){
  logger.info("randomRemoveExpiredCache -- 清理结果 -- "+ lastGCInfo); 
 }
 }
 
 private boolean removeExpiredKey(Object key){
 boolean flag = false;
 
 CacheElement cacheObj = null;
 if(null != key){
  try{
  cacheObj = cacheMap.get(key);
  boolean isExpiredCache = this.isExpiredCache(cacheObj);
  if(isExpiredCache){
   cacheMap.remove(key);
   flag = true;
  }
  }catch(Exception e){
  logger.error("removeExpired(" + key + ") -- error: " + e.getMessage(), e);
  }
 }
 
 if(!flag && logGCDetail){
  this.logger.warn("removeExpiredKey(" + key + ") return [" + flag + "]--" + cacheObj);
 }
 
 return flag;
 }
 
 public int getInitialCapacity() {
 return initialCapacity;
 }

 public int getMaxCapacity() {
 return maxCapacity;
 }

 public int getGcMode() {
 return gcMode;
 }

 public void setGcMode(int gcMode) {
 this.gcMode = gcMode;
 }

 public int getGcIntervalTime() {
 return gcIntervalTime;
 }

 public void setGcIntervalTime(int gcIntervalTime) {
 this.gcIntervalTime = gcIntervalTime;
 }

 public boolean isEnableGC() {
 return enableGC;
 }

 public void setEnableGC(boolean enableGC) {
 this.enableGC = enableGC;
 }
 
 public boolean isIterateScanAll() {
 return iterateScanAll;
 }
 public void setIterateScanAll(boolean iterateScanAll) {
 this.iterateScanAll = iterateScanAll;
 }
 public float getGcFactor() {
 return gcFactor;
 }

 public void setGcFactor(float gcFactor) {
 this.gcFactor = gcFactor;
 }
 
 /**
 * gc 阀值
 * @return
 */
 public int getGcThreshold() {
 int threshold = (int)( this.cacheMap.getMaxCapacity() * gcFactor );
 return threshold;
 }

 public String getLastGCInfo() {
 return lastGCInfo;
 }

 public void setLastGCInfo(String lastGCInfo) {
 this.lastGCInfo = lastGCInfo;
 }
 
 public boolean isLogGCDetail() {
 return logGCDetail;
 }
 public void setLogGCDetail(boolean logGCDetail) {
 this.logGCDetail = logGCDetail;
 }
 public int getTimeout() {
 return timeout;
 }
 public void setTimeout(int timeout) {
 this.timeout = timeout;
 }
 public int getMaxIterateSize() {
 return maxIterateSize;
 }
 public void setMaxIterateSize(int maxIterateSize) {
 this.maxIterateSize = maxIterateSize;
 }
 public int getMaxRandomTimes() {
 return maxRandomTimes;
 }
 public void setMaxRandomTimes(int maxRandomTimes) {
 this.maxRandomTimes = maxRandomTimes;
 }
 public boolean isInitFlag() {
 return initFlag;
 }
 public long getDefaultLifeTime() {
 return defaultLifeTime;
 }

 public boolean isWarnLongerLifeTime() {
 return warnLongerLifeTime;
 }

 public void setWarnLongerLifeTime(boolean warnLongerLifeTime) {
 this.warnLOngerLifeTime= warnLongerLifeTime;
 }

 //======================== dynMaxCapacity ========================
 private int dynMaxCapacity = maxCapacity;
 public int getDynMaxCapacity() {
 return dynMaxCapacity;
 }
 public void setDynMaxCapacity(int dynMaxCapacity) {
 this.dynMaxCapacity = dynMaxCapacity;
 }
 public void resetMaxCapacity(){
 if(dynMaxCapacity > initialCapacity && dynMaxCapacity != maxCapacity){
  
  if(logger.isInfoEnabled()){
  logger.info("resetMaxCapacity( " + dynMaxCapacity + " ) start...");
  }
  
  synchronized(cacheMap){
  LRULinkedHashMap cacheMap0 = new LRULinkedHashMap(initialCapacity ,dynMaxCapacity);
  cacheMap.clear();
  cacheMap = cacheMap0;
  this.maxCapacity = dynMaxCapacity;
  }
  
  if(logger.isInfoEnabled()){
  logger.info("resetMaxCapacity( " + dynMaxCapacity + " ) OK.");
  }
 }else {
  if(logger.isWarnEnabled()){
  logger.warn("resetMaxCapacity( " + dynMaxCapacity + " ) NO.");
  }
 }
 }
 //======================== showCacheElement ========================
 private String showCacheKey;
 public String getShowCacheKey() {
 return showCacheKey;
 }
 public void setShowCacheKey(String showCacheKey) {
 this.showCacheKey = showCacheKey;
 }
 public Object showCacheElement(){
 Object v = null;
 
 if(null != this.showCacheKey){
  v = cacheMap.get(showCacheKey);
 }
 
 return v;
 }
}