IT工程師數位筆記本

/* 
 @author blackbeans
 *  
 * 背景知識: 
 *          而對于SoftReference而言它被GC回收的條件就沒那么嚴格了， 
 *          如果一個對象當前最強的引用是軟引用，并且JVM的內存充足， 
 *          垃圾回收器是不會回收的該對象的。只有在內存比較吃緊的情況下GC才會回收被軟引用指向的對象， 
 *          從這個特點我們就看出了軟引用可以用來做一些高速緩存，配合LRU策略更好。今天我就自己寫一個玩玩。 
 *  
 *          而對于SoftReference而言它被GC回收的條件就沒那么嚴格了， 
 *          如果一個對象當前最強的引用是軟引用，并且JVM的內存充足， 
 *          垃圾回收器是不會回收的該對象的。 
 *          只有在內存比較吃緊的情況下GC才會回收被軟引用指向的對象， 
 *          從這個特點我們就看出了軟引用可以用來做一些高速緩存，配合LRU策略更好。 
 *  
 */
public class ReferenceCache<K, T> {

    private HashMap<K, InnerReference<K, T>> cachedReference = new HashMap<K, InnerReference<K, T>>(1024);

    private final ReferenceQueue<T> referenceQueue;

    private final ObjectNotFoundHandler<K, T> existsHandler;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * 緩存中取不到時的處理器 接口
     *
     * @author blackbeans
     *
     * @param <K>
     * @param <T>
     */
    public static interface ObjectNotFoundHandler<K, T> {

        public T queryAndCached(K key);
    }

    /**
     * 默認緩存中取不到時的處理器 實現類
     *
     * @author blackbeans
     *
     * @param <K>
     * @param <T>
     */
    private static class DefaultObjectNotFoundHandler<K, T> implements ObjectNotFoundHandler<K, T> {

        @Override
        public T queryAndCached(K key) {
            return null;
        }

    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * 繼承軟引用
     *
     * @param <K>
     * @param <T>
     */
    private static class InnerReference<K, T> extends SoftReference<T> {

        private final K key;

        public InnerReference(K key, T reference, ReferenceQueue<T> queue) {
            super(reference, queue);
            this.key = key;
        }

        public K getKey() {
            return this.key;
        }
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * 本類構造方法
     *
     * @param handler
     */
    public ReferenceCache(ObjectNotFoundHandler<K, T> handler) {
        this.referenceQueue = new ReferenceQueue<T>();
        this.existsHandler = handler == null ? new DefaultObjectNotFoundHandler<K, T>() : handler;
    }

    public ReferenceCache() {
        this(null);
    }

    /**
     * 清除給定key的緩存
     *
     * @param key
     */
    @SuppressWarnings("unchecked")
    private void cleanReference(K key) {
        //優先檢查key對應軟引用的對象是否被回收     
        if (this.cachedReference.containsKey(key) && this.cachedReference.get(key).get() == null) {
            this.cachedReference.remove(key);
        }
        T obj = null;
        //如果當前Key對應的軟引用的對象被回收則移除該Key     
        Reference<? extends T> reference = null;
        while ((reference = this.referenceQueue.poll()) != null) {
            obj = reference.get();
            if (obj == null) {
                this.cachedReference.remove(((InnerReference<K, T>) reference).getKey());
            }
        }
    }

    /**
     * 把需要緩存的數據放入緩存池
     *
     * @param key
     * @param reference
     */
    public void put(K key, T reference) {//cachedReference
        /**
         * 清除被軟引用的對象并已經被回收的reference
         */
        cleanReference(key);
        if (!this.cachedReference.containsKey(key)) {
            this.cachedReference.put(key, new InnerReference<K, T>(key, reference, this.referenceQueue));
        }
    }

    /**
     * 獲取緩存池內的換成對象
     *
     * @param key
     * @return
     */
    public T get(K key) {//getReference

        T obj = null;

        if (this.cachedReference.containsKey(key)) {
            obj = this.cachedReference.get(key).get();
        }

        if (null == obj) {
            /**
             * 軟引用指向的對象被回收,并緩存該軟引用
             */
            obj = this.existsHandler.queryAndCached(key);
            this.put(key, obj);
            return obj;
        }
        return obj;

    }

    /**
     * 清空所有緩存
     */
    public void clearALLObject() {
        this.cachedReference.clear();
        System.gc();
    }

    public boolean containsKey(Object key) {
        return cachedReference.containsKey(key);
    }

    public static void main(String[] args) {
        ReferenceCache cache = new ReferenceCache();
        cache.put("11", new SiteBean());
        System.out.println(cache.get("11"));
        cache.cleanReference("11");
        cache.clearALLObject();
    }