`

集合框架 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;
    }

}


分享到:
评论

相关推荐

    java.util包总结

    12. WeakHashMap:键使用弱引用的Map,当键不再被引用时,条目会自动从Map中移除。 13. Timer和TimerTask:定时任务调度,可以安排一次或周期性的任务执行。 14. Bitset:位集,用于高效存储和操作位标志。 15. ...

    java集合框架 解析

    java集合框架 3.6. LinkedHashSet类 4. Map接口 4.1. Map.Entry接口 4.2. SortedMap接口 4.3. AbstractMap抽象类 4.4. HashMap类和TreeMap类 4.4.1. HashMap类 4.4.2. TreeMap类 4.5. LinkedHashMap类 4.6. ...

    Java 集合框架+集合实例

    Java集合框架是Java编程语言中用于存储和管理对象的核心组件,它为开发者提供了灵活且高效的数据结构选择。这个框架的设计目标是确保高性能、高度互操作性以及易于扩展。以下是对标题和描述中涉及的知识点的详细说明...

    数据结构和Java集合框架

    数据结构和Java集合框架是Java编程中至关重要的概念,它们是高效编程和算法设计的基础。在Java中,数据结构指的是组织、存储和管理数据的方式,而集合框架则是一组接口和类,为处理各种数据结构提供了统一的API。 ...

    浅谈java集合框架

    本篇文章将详细探讨Java集合框架中的一些核心概念和技术细节。 #### 1. Collection与Collections的区别 - **Collection**:这是一个接口,位于`java.util`包中,它定义了一系列方法来操作一个对象的集合。它是所有...

    JAVASE6.0_Api_en\docs\api

    Java 6中的集合框架是编程中的核心部分,它在`java.util`包下,包括List、Set、Map等接口以及它们的实现类。ArrayList和LinkedList实现了List接口,分别提供基于数组和链表的数据存储方式。HashSet和TreeSet实现了...

    一个讲解很清晰的Java集合框架PPT

    Java集合框架是Java编程语言中不可或缺的一部分,它提供了一组接口和类,用于高效地存储、管理和操作数据。这个“一个讲解很清晰的Java集合框架PPT”显然是一个对外公开的教育资源,旨在帮助学习者深入理解Java集合...

    java集合-WeakHashMap的使用

    WeakHashMap是Java中的一种特殊的哈希表实现,它使用弱引用(Weak Reference)来保存键对象。当键对象没有被其他强引用引用时,在垃圾回收时会自动从WeakHashMap中移除对应的键值对。

    学习Java集合框架全面介绍.pdf

    集合框架的核心是`java.util`包下的`Collection`接口和`Map`接口,它们定义了处理对象集合的一系列通用操作。 `Collection`接口是最基础的集合接口,代表了一组Object的集合,可以通过迭代器`Iterator`遍历其元素。...

    区别和联系-list-map-set-vector

    List 是 Java 集合框架中的一个接口,它允许元素重复,并且每个元素都有一个特定的顺序位置。这意味着可以通过索引来访问 List 中的元素。List 提供了多种实现类,包括 `LinkedList`、`ArrayList`、`Vector` 和 `...

    Java 2集合框架图

    Java 2集合框架是Java语言中用于存储和管理对象的核心组件,它提供了一套标准的接口和类,使得程序员能够高效地操作数据集合。这个框架的设计目标是提高代码的复用性和灵活性,允许开发者根据需求选择不同的数据结构...

    Java 基础核心总结 +经典算法大全.rar

    什么是 Java2 Java 的特点Java 开发环境 JDK JRE Java 开发环境配置 Java 基本语法 数据类型基础语法运算符 Java 执行控制流程条件语句 if 条件语句 if...else 条件语句if...else if 多分支语句switch 多分支语句 ...

    java-all.pdf

    Java 提供了丰富的集合框架,包括列表、集合和映射等。 - **List**:有序的元素集合。 - **ArrayList**:动态数组实现的列表。 - **LinkedList**:双向链表实现的列表。 - **Vector**:线程安全的列表。 - **Set...

    超全Java集合框架讲解.md

    ### 超全Java集合框架讲解 #### 集合框架总览 Java集合框架是Java编程语言中处理数据结构的基础。它为开发者提供了一系列高度优化的数据存储与操作方法,使得开发者可以更加专注于业务逻辑而无需担心底层实现细节...

    Map-main-源码.rar

    Map接口是Java集合框架中的重要组成部分,它提供了一种存储键值对数据结构的方式,使得我们可以通过键(Key)快速查找对应的值(Value)。在Java中,有许多实现了Map接口的类,如HashMap、TreeMap、LinkedHashMap等...

    20个最佳的Java集合框架面试题目.zip

    Java集合框架是Java编程语言中不可或缺的一部分,它提供了一种高效、灵活的方式来存储和操作数据。面试中,Java集合框架的题目通常会测试应聘者对数据结构、算法以及API的理解。以下是对Java集合框架的一些核心知识...

Global site tag (gtag.js) - Google Analytics