当前位置:首页 > 开发 > 编程语言 > Java > 正文

Java-Collections Framework学习与总结-WeakHashMap

发表于: 2013-09-02   作者:BrokenDreams   来源:转载   浏览:
摘要:         总结这个类之前,首先看一下Java引用的相关知识。Java的引用分为四种:强引用、软引用、弱引用和虚引用。         强引用:就是常见的代码中的引用,如Object o = new Object();存在强引用的对象不会被垃圾收集
        总结这个类之前,首先看一下Java引用的相关知识。Java的引用分为四种:强引用、软引用、弱引用和虚引用。

        强引用:就是常见的代码中的引用,如Object o = new Object();存在强引用的对象不会被垃圾收集器回收。所以我们会在一些代码中看到显示切断强引用,以便回收相关对象的情况。
public void clear() {
	modCount++;

	// Let gc do its work
	for (int i = 0; i < size; i++)
	    elementData[i] = null;

	size = 0;
}


        软引用:比强引用弱一些,表示对一些有用但非必须对象的引用。这些对象会在将要发生内存溢出异常之前被回收。在Java中用java.lang.ref.SoftReference来表示软引用。看一个例子,先设置下JVM参数,将堆大小设为10m,老年代新生代各5m,打印出GC日志。
JVM参数
-Xms10m -Xmx10m -Xmn5m -XX:+PrintGCDetails

	public static void main(String[] args) {
		//构造一个3M的对象
		Object _3m_1 = new byte[1024 * 1024 * 3];
		//创建软引用
		SoftReference<Object> reference = new SoftReference<Object>(_3m_1);
		//切断强引用
		_3m_1 = null;
		//再构造一个3M的对象
		Object _3m_2 = new byte[1024 * 1024 * 3];
		//触发Full GC
		System.gc();
		System.out.println("软引用关联对象:"+reference.get());
	}

        输出结果:
[GC [DefNew: 3325K->152K(4608K), 0.0023022 secs] 3325K->3224K(9728K), 0.0023380 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System) [Tenured: 3072K->3072K(5120K), 0.0057404 secs] 6378K->6296K(9728K), [Perm : 380K->380K(12288K)], 0.0057837 secs] [Times: user=0.02 sys=0.00, real=0.02 secs] 
软引用关联对象:[B@14318bb
Heap
 def new generation   total 4608K, used 3350K [0x31fe0000, 0x324e0000, 0x324e0000)
  eden space 4096K,  81% used [0x31fe0000, 0x32325880, 0x323e0000)
  from space 512K,   0% used [0x32460000, 0x32460000, 0x324e0000)
  to   space 512K,   0% used [0x323e0000, 0x323e0000, 0x32460000)
 tenured generation   total 5120K, used 3072K [0x324e0000, 0x329e0000, 0x329e0000)
   the space 5120K,  60% used [0x324e0000, 0x327e0010, 0x327e0200, 0x329e0000)
 compacting perm gen  total 12288K, used 380K [0x329e0000, 0x335e0000, 0x369e0000)

        基本过程是这样,程序先创建了一个3M的对象_3m_1,这个对象被分配到新生代里面,然后创了一个软引用关联到_3m_1,然后切断_3m_1的强引用。接下来又创建了一个3M的对象_3m_2,_3m_2要试图分配到新生代,这时发现新生代剩余空间不足(一共4608K,已经有一个3M的对象在里面)。接下来触发了一次新生代的垃圾收集动作(Minor GC),但这次收集没有回收掉_3m_1。然后_3m_1晋升到老年代,_3m_2被分配到新生代。接下来程序显示触发了一次Full GC,但这次Full GC似乎没起什么作用,_3m_1和_3m_2都安然无恙。
        那么修改一下程序,再跑一次看看:
	public static void main(String[] args) {
		//构造一个3M的对象
		Object _3m_1 = new byte[1024 * 1024 * 3];
		//创建软引用
		SoftReference<Object> reference = new SoftReference<Object>(_3m_1);
		//切断强引用
		_3m_1 = null;
		//再构造一个3M的对象
		Object _3m_2 = new byte[1024 * 1024 * 3];
		//又构造一个3M的对象
		Object _3m_3 = new byte[1024 * 1024 * 3];
		System.out.println("软引用关联对象:"+reference.get());
	}

        输出结果:
[GC [DefNew: 3325K->152K(4608K), 0.0021553 secs] 3325K->3224K(9728K), 0.0021908 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC [DefNew: 3224K->3224K(4608K), 0.0000288 secs][Tenured: 3072K->3072K(5120K), 0.0060759 secs] 6296K->6296K(9728K), [Perm : 380K->380K(12288K)], 0.0061594 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC [Tenured: 3072K->3210K(5120K), 0.0049693 secs] 6296K->3210K(9728K), [Perm : 380K->375K(12288K)], 0.0050152 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 
软引用关联对象:null
Heap
 def new generation   total 4608K, used 3280K [0x31fe0000, 0x324e0000, 0x324e0000)
  eden space 4096K,  80% used [0x31fe0000, 0x32314050, 0x323e0000)
  from space 512K,   0% used [0x32460000, 0x32460000, 0x324e0000)
  to   space 512K,   0% used [0x323e0000, 0x323e0000, 0x32460000)
 tenured generation   total 5120K, used 3210K [0x324e0000, 0x329e0000, 0x329e0000)
   the space 5120K,  62% used [0x324e0000, 0x32802b28, 0x32802c00, 0x329e0000)

        前面的过程和上面类似,区别在创建第三个3M对象_3m_3时,首先触发了一次Minor GC,没回收什么东西,但是要把新生代里的_3m_2放到老年代,这样才能腾出地方给_3m_3。但是老年代已经有_3m_1了,剩余的空间不足以放下_3m_2,这时系统触发了Full GC(不用我们触发system Full GC了)。从日志上看似乎回收掉了3M的空间。说明在内存溢出之前,软引用关联的对象被回收了。这便是软引用的特性,如果这里是一个强引用的话,那么便会出现OOM了。

        弱引用:比软引用还弱一些,所以关联的对象在下一次垃圾收集的时候就会被回收掉。继续看例子,JVM参数同上。
	public static void main(String[] args) {
		//构造一个3M的对象
		Object _3m_1 = new byte[1024 * 1024 * 3];
		//创建软引用
		WeakReference<Object> reference = new WeakReference<Object>(_3m_1);
		//切断强引用
		_3m_1 = null;
		//触发Full GC
		System.gc();
		System.out.println("软引用关联对象:"+reference.get());
	}

        输出结果:
[Full GC (System) [Tenured: 0K->152K(5120K), 0.0086388 secs] 3325K->152K(9728K), [Perm : 380K->380K(12288K)], 0.0086922 secs] [Times: user=0.01 sys=0.00, real=0.01 secs] 
软引用关联对象:null
Heap
 def new generation   total 4608K, used 208K [0x31fe0000, 0x324e0000, 0x324e0000)
  eden space 4096K,   5% used [0x31fe0000, 0x32014040, 0x323e0000)
  from space 512K,   0% used [0x323e0000, 0x323e0000, 0x32460000)
  to   space 512K,   0% used [0x32460000, 0x32460000, 0x324e0000)
 tenured generation   total 5120K, used 152K [0x324e0000, 0x329e0000, 0x329e0000)
   the space 5120K,   2% used [0x324e0000, 0x32506088, 0x32506200, 0x329e0000)


        虚引用:虚引用一般用来代替finalize方法来做一些引用对象被回收前的清理动作(由于finalize的不确定性,不建议使用)。虚引用必须配合一个ReferenceQueue一起使用,在GC决定要回收其引用对象时(引用对象没有任何强引用关联),虚引用会入栈,程序中可以在这个时机做一些清理工作。虚引用的get方法返回null:
public class PhantomReference<T> extends Reference<T> {

    /**
     * Returns this reference object's referent.  Because the referent of a
     * phantom reference is always inaccessible, this method always returns
     * <code>null</code>.
     *
     * @return  <code>null</code>
     */
    public T get() {
	return null;
    }

        这样保证了虚引用的关联对象永远不可能通过get方法再次获得强引用。但虚引用的关联对象要一直等到虚引用本身不可达或者被回收时才能够被回收,这点不同于软引用和弱引用。
  
        最后说一下java.lang.ref.ReferenceQueue。ReferenceQueue是一个引用队列,构造一个软引用、弱引用或者虚引用可以传入一个ReferenceQueue,表示这个引用注册到传入的引用队列上,简单的说,当GC决定回收引用关联对象时,会将这个引用放到引用队列里。

        大概了解了Java引用的相关内容,现在可以看下java.util.WeakHashMap的源码了。
        整体看下来,其实和 HashMap差不多,所以只看一下差异的地方。
    /**
     * Reference queue for cleared WeakEntries
     */
    private final ReferenceQueue<K> queue = new ReferenceQueue<K>();

        WeakHashMap中多了一个引用队列的变量,大概能猜到是干什么的了吧。
      
        看下WeakHashMap中的Entry:
    /**
     * The entries in this hash table extend WeakReference, using its main ref
     * field as the key.
     */
    private static class Entry<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());
        }

        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();
        }
    }

        java.util.WeakHashMap.Entry扩展自java.lang.ref.WeakReference,将Key(Map中的键)作为虚引用的关联对象。
        由于WeakHashMap本身允许键值为null,所以这里不同于HashMap,需要利用一些转化函数。
    /**
     * Value representing null keys inside tables.
     */
    private static final Object NULL_KEY = new Object();

    /**
     * Use NULL_KEY for key if it is null.
     */
    private static Object maskNull(Object key) {
        return (key == null ? NULL_KEY : key);
    }

    /**
     * Returns internal representation of null key back to caller as null.
     */
    private static <K> K unmaskNull(Object key) {
        return (K) (key == NULL_KEY ? null : key);
    }

        由于虚引用的性质,当WeakHashMap中的某个Key已经没有外部的强引用,那么在接下来发生的垃圾收集动作里,它将会被回收。这里要注意一下,回收的仅仅是Key,但是Entry还在呢(也可以说是虚引用本身)。
        所以在一些操作里会调用expungeStaleEntries方法,这个方法里会清理所有Key已经被回收的Entry。
    /**
     * Expunges stale entries from the table.
     */
    private void expungeStaleEntries() {
	Entry<K,V> e;
        while ( (e = (Entry<K,V>) queue.poll()) != null) {
            int h = e.hash;
            int i = indexFor(h, 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;
                    e.next = null;  // Help GC
                    e.value = null; //  "   "
                    size--;
                    break;
                }
                prev = p;
                p = next;
            }
        }
    }

    /**
     * Returns the table after first expunging stale entries.
     */
    private Entry[] getTable() {
        expungeStaleEntries();
        return table;
    }

    /**
     * Returns the number of key-value mappings in this map.
     * This result is a snapshot, and may not reflect unprocessed
     * entries that will be removed before next attempted access
     * because they are no longer referenced.
     */
    public int size() {
        if (size == 0)
            return 0;
        expungeStaleEntries();
        return size;
    }

        基本上差异就是这些。WeakHashMap本身的特性也使它经常被应用到一些缓存的场景。

Java-Collections Framework学习与总结-WeakHashMap

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
开发中有时会遇到这样的情况。要求某个调度器去调度一些任务,这些任务放在队列里。任务本身有优先
System.Data.EntityClient EntityClient 提供程序使用存储特定的 ADO.NET 数据提供程序类和映射元数
介绍 LINQ to Entities 使开发人员能够通过使用 LINQ 表达式和 LINQ 标准查询运算符,直接从开发环
POCO Entity Framework 4.0 为实体提供了简单传统 CLR 对象( Plain Old CLR Object / POCO )支持
这一章,我们对WeakHashMap进行学习。 我们先对WeakHashMap有个整体认识,然后再学习它的源码,最后
System.Data.Objects (System.Data.Entity.dll) 该命名空间包含一些类,用于提供对 对象服务 的核心
Entity SQL Language 简介 什么是 Entity SQL Entity SQL 类似 SQL 语言,它的存在是为了查询 ADO.N
Entity SQL 基本查询 SWFGHO 是什么? SELECT-FROM-WHERE-GROUP BY-HAVING-ORDER BY 的首字母缩写,
复杂查询及函数 外键 Entity SQL 与其它的查询一样,可以通过外键的关系直接取值或判断,如: using
加载相关对象 实体类型可以定义在数据模型中表示关联的导航属性。可以使用这些属性加载与所定义的关
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号