本地快取機制，利用java.util.concurrent，很好的管理本地記憶體儲存的物件內容。

建立屬性：

 /**
     * 具體內容存放的地方
     */
    private ConcurrentHashMap<String, Object>[] caches;
    /**
     * 超期資訊儲存
     */
    private ConcurrentHashMap<String, Long> expiryCache;

    /**
     * 清理超期內容的服務
     */
    private ScheduledExecutorService scheduleService;


    /**
     * 清理超期資訊的時間間隔，預設10分鐘
     */
    private int expiryInterval = 5;


    /**
     * 內部cache的個數，根據key的hash對module取模來定位到具體的某一個內部的Map，
     */
    private int moduleSize = 10;

建立構造器：    

  public MyLocalCache() {
        caches = new ConcurrentHashMap[moduleSize];
        for (int i = 0; i < moduleSize; i++) {
            caches[i] = new ConcurrentHashMap<String, Object>();
        }
        expiryCache = new ConcurrentHashMap<String, Long>();


        scheduleService = Executors.newScheduledThreadPool(1);
        //後臺定時維護執行緒
        scheduleService.scheduleAtFixedRate(getRemoveLocalCacheTask(), 0, 60L * expiryInterval, TimeUnit.SECONDS);
    }

定義快取的get和put方法：

  /**
     * 將資料放入快取中
     * @param key
     * @param value
     * @param TTL 秒
     * @return
     */
    public Object put(String key, Object value, int TTL) {
        Object result = null;
        ConcurrentHashMap<String, Object> cache = getCache(key);
        if (cache != null && cache.size() < 10240) {
            result = cache.put(key, value);
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.SECOND, TTL);
            expiryCache.put(key, calendar.getTime().getTime());
        }
        return result;
    }


    public Object get(String key) {
        checkValidate(key);
        return getCache(key).get(key);
    }

//根據key獲取cache容器
    private ConcurrentHashMap<String, Object> getCache(String key) {
        long hashCode = (long) key.hashCode();
        if (hashCode < 0) {
            hashCode = -hashCode;
        }
        int moudleNum = (int) (hashCode % moduleSize);
        return caches[moudleNum];
    }

校驗key是否過期，如果過期了，就要移除

 private void checkValidate(String key) {
        if (key != null) {
            Long expiryTime = expiryCache.get(key);
            if (expiryTime != null && expiryTime != -1
                    && new Date(expiryTime).before(new Date())) {
                ConcurrentHashMap<String, Object> cache = getCache(key);
                if (cache != null) {
                    cache.remove(key);
                }
                expiryCache.remove(key);
            }
        }
    }

清除所有的快取：    key和內容  全部清空

 public boolean clear() {
        if (caches != null) {
            for (ConcurrentHashMap<String, Object> cache : caches) {
                cache.clear();
            }
        }


        if (expiryCache != null) {
            expiryCache.clear();
        }
        return true;
    }

定時器：  檢查過期內容

 public Runnable getRemoveLocalCacheTask() {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    for (ConcurrentHashMap<String, Object> cache : caches) {
                        Iterator<String> keys = cache.keySet().iterator();
                        while (keys.hasNext()) {
                            String key = keys.next();
                            if (expiryCache.get(key) == null) {
                                continue;
                            }
                            long date = expiryCache.get(key);
                            if ((date > 0) && (new Date(date).before(new Date()))) {
                                expiryCache.remove(key);
                                cache.remove(key);
                            }
                        }
                    }
                    logger.debug("MingpinLocalCache CheckService check() is run!");
                } catch (Exception ex) {
                    logger.error(ex);
                }
            }
        };
    }