private final ReferenceQueue<Object> queue = new ReferenceQueue<>();	// 定義一個隊列，GC會自動將綁定到了此隊列的weak實例入隊到此隊列，用戶應(yīng)當(dāng)在每次訪問weak實例前，都要檢查實例是否已經(jīng)被GC入隊到此隊列中，如果是，說明實例已經(jīng)被GC，應(yīng)當(dāng)放棄使用。
	...
	private static class Entry<K,V> extends WeakHashMap<Object> implements Map.Entry<K,V>{
		V value;
		int hash;
		Entry<K,V> next;
		Entry(Object key, V value, ReferenceQueue queue, int hash, Entry<K,V> next){
			super(key, queue);	// 調(diào)用父類WeakReference的構(gòu)造方法，設(shè)置referent = key, queue = refQueue;
			this.value = value; 
			this.hash = hash;
			this.next = next;
		}
	}

   /**
     * Reference queue for cleared WeakEntries
     */
    private final ReferenceQueue<Object> queue = new ReferenceQueue<>();

private static class Entry<K,V> extends WeakReference<Object> implements Map.Entry<K,V> {
	 V value;
        final int hash;
        Entry<K,V> next;
        /**
         * Creates new entry.
         */
        Entry(Object key, V value,
              ReferenceQueue<Object> queue,
              int hash, Entry<K,V> next) {
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }
	@SuppressWarnings("unchecked")
        public K getKey() {
            return (K) WeakHashMap.unmaskNull(get());
        }
        public int hashCode() {      /* 重寫實現(xiàn)了Object類中的hashCode，此方法是計算整個Entry實例對象的hashCode，不是計算key的hashCode */
            K k = getKey();
            V v = getValue();
            return Objects.hashCode(k) ^ Objects.hashCode(v);
        }
}

private Entry<K,V>[] getTable(){
	Entry<K,V>[] table = expungeStaleEntries();
	return table;
}
/**
     * Expunges stale entries from the table.
     */
    private void expungeStaleEntries() {
        for (Object x; (x = queue.poll()) != null; ) {
            synchronized (queue) {
                @SuppressWarnings("unchecked")
                    Entry<K,V> e = (Entry<K,V>) x;
                int i = indexFor(e.hash, table.length);
                Entry<K,V> prev = table[i];
                Entry<K,V> p = prev;
                while (p != null) {
                    Entry<K,V> next = p.next;
                    if (p == e) {
                        if (prev == e)
                            table[i] = next;
                        else
                            prev.next = next;
                        // Must not null out e.next;
                        // stale entries may be in use by a HashIterator
                        e.value = null; // Help GC
                        size--;
                        break;
                    }
                    prev = p;
                    p = next;
                }
            }
        }
    }

   public V get(Object key) {
        Object k = maskNull(key);
        int h = hash(k);
        Entry<K,V>[] tab = getTable();
        int index = indexFor(h, tab.length);
        Entry<K,V> e = tab[index];
        while (e != null) {
            if (e.hash == h && eq(k, e.get()))
                return e.value;
            e = e.next;
        }
        return null;
    }

public final class ConcurrentCache<K,V>{
	private  final int size;
	private  final Map<K,V> eden;    //新創(chuàng)建的，最近使用的，放在eden里。
	private final Map<K,V> longTerm;    // 當(dāng)eden滿了后，將eden里的所有對象移動到longTerm里。longTerm是一個WeakHashMap，GC及時清理其中的數(shù)據(jù)。
	public ConcurrentCache(int  size){
		this.size=size;
		eden= new ConcurrentHashMap(size);
		longTerm = new WeakHashMap();
	}
	public V get(K k){     /* 被get，最新被使用了，必須要在eden中*/
		V v = eden.get(k) ;
		if(v==null){
			synchronized(longTerm){
			  v = longTerm.get(k);			
			}
			if(v!=null){
				eden.put(k,v);
			}		    
		}
		return v;	
	}
	public V put(K K,V v){   /*最新創(chuàng)建的，放到eden中*/
		if(eden.size()>=size){
			synchronized(longTerm){
				longTerm.putAll(eden);
			}
			eden.clear();
		}
		eden.put(k,v);
	}
}