采用静态Map、ConcurrentHashMap处理缓存

考虑到在使用HashMap在并发时会出现不正确行为，根据网上资料自己编写了采用ConcurrentHashMap来完成静态缓存的处理，目的是为了能够用来处理高并发的线程安全类，如有问题请各位大侠指教：

 package com.zengms.cache;

 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 public class MapCacheManager {

     private final static Log log = LogFactory.getLog(MapCacheManager.class);

     private volatile long updateTime = 0L;// 更新缓存时记录的时间

     private volatile boolean updateFlag = true;// 正在更新时的阀门，为false时表示当前没有更新缓存，为true时表示当前正在更新缓存

     private volatile static MapCacheManager mapCacheObject;// 缓存实例对象

     private static Map cacheMap = new ConcurrentHashMap();// 缓存容器

     private MapCacheManager() {
         this.LoadCache();// 加载缓存
         updateTime = System.currentTimeMillis();// 缓存更新时间

     }

     /**
      * 采用单例模式获取缓存对象实例
      *
      * @return
      */
     public static MapCacheManager getInstance() {
         if (null == mapCacheObject) {
             synchronized (MapCacheManager.class) {
                 if (null == mapCacheObject) {
                     mapCacheObject = new MapCacheManager();
                 }
             }
         }
         return mapCacheObject;
     }

     /**
      * 装载缓存
      */
     private void LoadCache() {

         this.updateFlag = true;// 正在更新

         /********** 数据处理，将数据放入cacheMap缓存中 **begin ******/
         cacheMap.put("key1", "value1");
         cacheMap.put("key2", "value2");
         cacheMap.put("key3", "value3");
         cacheMap.put("key4", "value4");
         cacheMap.put("key5", "value5");
         /********** 数据处理，将数据放入cacheMap缓存中 ***end *******/

         this.updateFlag = false;// 更新已完成

     }

     /**
      * 返回缓存对象
      *
      * @return
      */
     public Map getMapCache() {

         long currentTime = System.currentTimeMillis();

         if (this.updateFlag) {// 前缓存正在更新
             log.info("cache is Instance .....");
             return null;

         }

         if (this.IsTimeOut(currentTime)) {// 如果当前缓存正在更新或者缓存超出时限，需重新加载
             synchronized (this) {
                 this.ReLoadCache();
                 this.updateTime = currentTime;
             }
         }

         return this.cacheMap;
     }

     private boolean IsTimeOut(long currentTime) {

         return ((currentTime - this.updateTime) > 1000000);// 超过时限，超时
     }

     /**
      * 获取缓存项大小
      * @return
      */
     private int getCacheSize() {
         return cacheMap.size();
     }

     /**
      * 获取更新时间
      * @return
      */
     private long getUpdateTime() {
         return this.updateTime;
     }

     /**
      * 获取更新标志
      * @return
      */
     private boolean getUpdateFlag() {
         return this.updateFlag;
     }

     /**
      * 重新装载
      */
     private void ReLoadCache() {
         this.cacheMap.clear();
         this.LoadCache();
     }

 }

测试代码：

 package com.zengms.cache;

 import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;

 public class CacheTest {

     public static void main(String[] args) {

         MapCacheManager cache = MapCacheManager.getInstance();
         Map cacheMap = new ConcurrentHashMap();

         cacheMap = cache.getMapCache();
         Set set = cacheMap.keySet();
         Iterator it = set.iterator();

         while(it.hasNext()){
             String key = it.next();
             System.out.println(key+"="+cacheMap.get(key));
         }
     }

 }