HashMap实现缓存

package com.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.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));
        }
    }

}