集合框架 Map篇（2）----WeakHashMap及java.lang.ref 持有引用

Map
------
1.HashMap
2.LinkedHashMap
3.IdentityHashMap
4.WeakHashMap
5.TreeMap
6.EnumMap
7.ConcurrentHashMap
8.ConcurrentSkipListMap

--------------------------------------------

4.WeakHashMap及java.lang.ref类库 持有引用

在分析WeakHashMap 之前先来看看java.lang.ref 类库 的持有引用相关的知识。

      java.lang.ref类库包含了一组类，这些类为垃圾回收提供了更大的灵活性。当存在可能消耗掉内存的大对象时，这些类显的特别重要。

有3个继承自Reference的类：SoftReference、WeakReference和PhantomReference。当垃圾回收器正在考察的对象只能通过某个Reference对象才“可获得”时，上述这些不同的派生类为垃圾回收器提供了不同级别的间接指示。

      对象是“可获得的”（reachable）指该对象在程序中某处 直接或间接的引用了。如果一个对象是“可获得的”，垃圾回收器就不能释放它，因为它仍在程序中使用。如果一个对象不是“可获得的”，表示程序中已经不存在对该对象的引用，这时将其回收是安全的。

       对象经过Reference包装后就能实现上述功能，不过该对象一定不能存在有普通对象（未经Reference包装的对象）引用之。

       SoftReference、WeakReference和PhantomReference由强到弱对于不同级别的“可获得性”：SoftReference用于实现内存敏感的高速缓存；WeakReference用于实现“规范映射”而设计的，“规范映射”中对象的实例可以在程序的多处使用以节省空间；PhantomReference用以调度回收前的清理工作，比java终止机制更为灵活。

       使用SoftReference和WeakReference时，可以选择是否要将它们放入ReferenceQueue（用作“回收前清理工作”的工具）。而PhantomReference只能依赖于ReferenceQueue。

----------------------

JVM的垃圾回收机制，和Java中存在的4种类型的引用有关：强引用，软引用，弱引用以及幻象引用。

       其中，HashMap采用的是类似强引用的强键来管理的，也就是说即使作为key的对象已经没有被任何对象引用了，它仍然会保存 在 HashMap中，在某些情况（如内存缓存）下，这些过期的对象会造成内存泄露。
      WeakHashMap采取的策略是，只要作为key的对象已经超出了生命周期，就不会阻止垃圾回收器对该对象的处理，即使在内存并不紧张的情况下。不过由于GC是一个优先级很低的线程，所以不能保证弱引用的对象超出生命周期后会立刻被清除。
      弱引用特别适用场景：占有大量内存，但通过垃圾回收功能回收以后很容易重新创建。
      软引用是只在内存紧张时才收集软可及对象。所以软引用比WeakHashMap采用的弱引用策略更适合于实现缓存机制。

      

 //有机会可以研究一下
        ReferenceQueue queue =new ReferenceQueue();
        queue.poll();

-----------

WeakHashMap被用来保存WeakReference。它使得规范映射更易于使用。在这中映射中，每个值只保存一份实例以节省存储空间。当程序中需要那个值的时候，便在映射中查询现有的对象，然后使用它（而不是重新new一个新对象）。映射可以将值作为其初始化的一部分，不过通常是在需要的时候才生成“值”。

      这是一种节约存储空间的技术，因为WeakHashMap允许垃圾回收器自动清理键和值，所以显得十分便利。对于想WeakHashMap添加键和值的操作，则没有什么特殊的要求。映射会自动使用WeakReference包装它们。

----------

WeakHashMap源码分析：

 public class WeakHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V> {

//....有多个成员变量，包括初始容量，负载因子等都和HashMap中的相似，这里不多说了

/**

*这是WeakHashMap中维持的一个引用队列，用于保存待要被垃圾回收器回收的WeakEntries(弱引用)
*/
 private final ReferenceQueue<K> queue = new ReferenceQueue<K>();

//.....

/**

*清除掉queue 中包含的引用，在getTable(),resize()和size()方法中有调用

*/

 private void expungeStaleEntries() {
 Entry<K,V> e;
        while ( (e = (Entry<K,V>) queue.poll()) != null) {//遍历整个queue
            int h = e.hash;
            int i = indexFor(h, table.length);//得到改元素在table中的位置

            Entry<K,V> prev = table[i];
            Entry<K,V> p = prev;
            while (p != null) {//遍历table i位置处的链表（和HashMap一样采用的next维持的链式结构）
                Entry<K,V> next = p.next;
                if (p == e) {//如果找到了queue中对应的e元素在链表中的引用
                    if (prev == e)//如果该元素在table 的i位置处（其实table中只存放最前面的那个元素），就把该处设置为next位置的元素
                        table[i] = next;
                    else// 否则，把perv的next定位到next上意思就是把queue中的e元素删除掉
                        prev.next = next;
                    e.next = null;  // Help GC  这里设null是为了更明显的体系GC，可以回收了
                    e.value = null; //  "   "
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }

    //去掉弱引用对象后的新Table

   private Entry[] getTable() {
        expungeStaleEntries();
        return table;
    }

  public V get(Object key) {
        Object k = maskNull(key);//key == null ? new Object(): key
        int h = HashMap.hash(k.hashCode());//调用HashMap的hash方法得到哈希值
        Entry[] tab = getTable();//这是去掉弱引用对象后的新Table
        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 V put(K key, V value) {
        K k = (K) maskNull(key);
        int h = HashMap.hash(k.hashCode());
        Entry[] tab = getTable();
        int i = indexFor(h, tab.length);

        for (Entry<K,V> e = tab[i]; e != null; e = e.next) {
            if (h == e.hash && eq(k, e.get())) {
                V oldValue = e.value;
                if (value != oldValue)
                    e.value = value;
                return oldValue;
            }
        }

        modCount++;
         Entry<K,V> e = tab[i];
        tab[i] = new Entry<K,V>(k, value, queue, h, e);//这里加入了 应用队列的包装
        if (++size >= threshold)
            resize(tab.length * 2);
        return null;
    }

 /**
     * 除了在创建Entry时添加了ReferenceQueue封装及extend WeakReference，其他的和HashMap.Entry的实现相似

     */
    private static classEntry<K,V> extends WeakReference<K> implements Map.Entry<K,V> {
        private V value;
        private final int hash;
        private Entry<K,V> next;

        /**
         * Creates new entry.
         */
        Entry(K key, V value, ReferenceQueue<K> queue, int hash, Entry<K,V> next) {
            super(key, queue);
            this.value = value;
            this.hash  = hash;
            this.next  = next;
        }

        public K getKey() {
            return WeakHashMap.<K>unmaskNull(get()); //通过引用得到key对象
        }

        public V getValue() {
            return value;
        }

        public V setValue(V newValue) {
     V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public boolean equals(Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            Map.Entry e = (Map.Entry)o;
            Object k1 = getKey();
            Object k2 = e.getKey();
            if (k1 == k2 || (k1 != null && k1.equals(k2))) {
                Object v1 = getValue();
                Object v2 = e.getValue();
                if (v1 == v2 || (v1 != null && v1.equals(v2)))
                    return true;
            }
            return false;
        }

        public int hashCode() {
            Object k = getKey();
            Object v = getValue();
            return  ((k==null ? 0 : k.hashCode()) ^
                     (v==null ? 0 : v.hashCode()));
        }

        public String toString() {
            return getKey() + "=" + getValue();
        }
    }

 

//.......

}

-------------------------------------

下面看一下：WeakReference和Reference的实现

WeakReference是Reference的子类，实现较为简单，就两个构造方法用于生成对象的引用

public class WeakReference<T> extends Reference<T> {

    /**
     * 创建一个引用，没有在引用队列中注册

     */
    public WeakReference(T referent) {
        super(referent);
    }

    /**
     * 创建一个引用，并且在指定的引用队列中注册

      */
    public WeakReference(T referent, ReferenceQueue<? super T> q) {
         super(referent, q);
    }

}

-----

public abstract class Reference<T> {

     private T referent;  /* Treated specially by GC */

    ReferenceQueue<? super T> queue;

    Reference next;
    transient private Reference<T> discovered;  /* used by VM */

    static private class Lock { };
    private static Lock lock = new Lock();

    /**

    *pending维护着一个等待入队的引用列表（通过next实现），垃圾收集器会把挂起的等待入列的引用添加到该列表中，

    *上面定义的lock就是为了维护这个列表而设置的

    */

    private static Reference pending = null;

 

    /**

     * 用高优先级线程把挂起的引用加入队列中
     */
    private static class ReferenceHandler extends Thread {

         ReferenceHandler(ThreadGroup g, String name) {
              super(g, name);
         }

         public void run() {
              for (;;) {

                            Reference r;
                           synchronized (lock) {
                                           if (pending != null) {
                                                  r = pending;
                                                  Reference rn = r.next;
                                                  pending = (rn == r) ? null : rn;
                                                  r.next = r;
                                            } else {
                                                   try {
                                                    lock.wait();
                                                  } catch (InterruptedException x) { }
                                                     continue;
                                             }
                             }

                           // Fast path for cleaners
                            if (r instanceof Cleaner) {
                                ((Cleaner)r).clean();
                                  continue;
                             }

                             ReferenceQueue q = r.queue;
                             if (q != ReferenceQueue.NULL) q.enqueue(r);
                  }
            }//run() 
    }//ReferenceHandler 

 

   static {//静态代码块，得到当前线程组的最顶层父类线程，并把优先级设置为最高

               ThreadGroup tg = Thread.currentThread().getThreadGroup();
                for (ThreadGroup tgn = tg; tgn != null;tg = tgn, tgn = tg.getParent());
                Thread handler = new ReferenceHandler(tg, "Reference Handler");
                 handler.setPriority(Thread.MAX_PRIORITY);
                 handler.setDaemon(true);
                 handler.start();
    }


    /* -- 引用对象的获得和清除 -- */

    public T get() {
         return this.referent;
    }

    public void clear() {
       this.referent = null;
    }

   /**

   * 由程序或垃圾回收器通知是否已将此引用对象加入队列。

   */
    public boolean isEnqueued() {
         synchronized (this) {
            return (this.queue != ReferenceQueue.NULL) && (this.next != null);
         }
    }

    /**
     * 将此引用对象添加到引用对象已向其注册的队列（如果有）。

     */
    public boolean enqueue() {
        return this.queue.enqueue(this);
    }


    /* -- 两个构造函数 -- */

    Reference(T referent) {
       this(referent, null);
    }

    Reference(T referent, ReferenceQueue<? super T> queue) {
         this.referent = referent;
         this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
    }

}