采用静态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<String, String> cacheMap = new ConcurrentHashMap<String, String>();// 缓存容器

	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<String, String> 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<String, String> cacheMap = new ConcurrentHashMap<String, String>();
		
		cacheMap = cache.getMapCache();
		Set<String> set = cacheMap.keySet();
		Iterator<String> it = set.iterator();
		
		while(it.hasNext()){
			String key = it.next();
			System.out.println(key+"="+cacheMap.get(key));
		}
	}

}