java中用静态变量map实现缓存

package com.terrace.common;


import java.util.Iterator;
import java.util.Map;  
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;  
public class MapCacheManager {  
   
  
    private volatile static MapCacheManager mapCacheObject;// 缓存实例对象  
  
    private volatile static Map<String, String> cacheMap = new ConcurrentHashMap<String, String>();// 缓存map
  
    /** 
     * 采用单例模式获取缓存对象实例 
     *  
     * @return 
     */  
    public static MapCacheManager getInstance() {  
        if (null == mapCacheObject) {  
            synchronized (MapCacheManager.class) {  
                if (null == mapCacheObject) {  
                    mapCacheObject = new MapCacheManager();  
                }  
            }  
        }  
        return mapCacheObject;  
    }  
  
    //set 
    public static void setMapCache(Map<String, String> map) {  
        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            cacheMap.put(key, map.get(key));
        }
    }  
    //get
    public static Map<String, String> getMapCache() {  
  
        return cacheMap;  
    }  
    //清除cache
    public static void clear(){
        cacheMap.clear();
    }
  

}  

将类中的方法定义为静态方法，变量定义为静态类，这样就可以全局进行访问了

另外需要做一个定时的调度的线程，去同步数据库中的数据，为了线程的安全性，将上述变量都置为volatile

   public String syncSourceData() {
        try {
            Thread r = new Thread() {
                public void run() {
                    try {
                        Map<String, String> map = new HashMap<String, String>();
                        //从数据库中取数据，push到map中
                        MapCacheManager.clear();
                        MapCacheManager.setMapCache(map);
                    } catch (Exception e) {
                    }
                }
            };
            r.start();
        } catch (Exception e) {
            
        }
        return ajax(SUCCESS);
    }