理解 Java 的 GC 与幽灵引用

Feiing

浏览: 240803 次
性别:
来自: 上海

最近访客更多访客>>

Liu951216

wusuosuo

angelshelter

ggg123111

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

技术

Java Cache JVM 虚拟机多线程

理解 Java 的 GC 与幽灵引用

         Java 中一共有 4 种类型的引用 : StrongReference、 SoftReference、 WeakReference 以及 PhantomReference (传说中的幽灵引用呵呵),
这 4 种类型的引用与 GC 有着密切的关系, 让我们逐一来看它们的定义和使用场景 :

        1. Strong Reference

        StrongReference 是 Java 的默认引用实现, 它会尽可能长时间的存活于 JVM 内，当没有任何对象指向它时 GC 执行后将会被回收

	@Test
	public void strongReference() {
		Object referent = new Object();
		
		/**
		 * 通过赋值创建 StrongReference 
		 */
		Object strongReference = referent;
		
		assertSame(referent, strongReference);
		
		referent = null;
		System.gc();
		
		/**
		 * StrongReference 在 GC 后不会被回收
		 */
		assertNotNull(strongReference);
	}

2. WeakReference & WeakHashMap

WeakReference，顾名思义, 是一个弱引用, 当所引用的对象在 JVM 内不再有强引用时, GC 后 weak reference 将会被自动回收

	@Test
	public void weakReference() {
		Object referent = new Object();
		WeakReference<Object> weakRerference = new WeakReference<Object>(referent);
	
		assertSame(referent, weakRerference.get());
		
		referent = null;
		System.gc();
		
		/**
		 * 一旦没有指向 referent 的强引用, weak reference 在 GC 后会被自动回收
		 */
		assertNull(weakRerference.get());
	}

WeakHashMap 使用 WeakReference 作为 key，一旦没有指向 key 的强引用, WeakHashMap 在 GC 后将自动删除相关的 entry

	@Test
	public void weakHashMap() throws InterruptedException {
		Map<Object, Object> weakHashMap = new WeakHashMap<Object, Object>();
		Object key = new Object();
		Object value = new Object();
		weakHashMap.put(key, value);
	
		assertTrue(weakHashMap.containsValue(value));
		
		key = null;
		System.gc();
		
		/**
		 * 等待无效 entries 进入 ReferenceQueue 以便下一次调用 getTable 时被清理
		 */
		Thread.sleep(1000);
		
		/**
		 * 一旦没有指向 key 的强引用, WeakHashMap 在 GC 后将自动删除相关的 entry
		 */
		assertFalse(weakHashMap.containsValue(value));
	}

3. SoftReference

SoftReference 于 WeakReference 的特性基本一致，最大的区别在于 SoftReference 会尽可能长的保留引用直到 JVM 内存不足时才会被回收(虚拟机保证), 这一特性使得 SoftReference 非常适合缓存应用

	@Test
	public void softReference() {
		Object referent = new Object();
		SoftReference<Object> softRerference = new SoftReference<Object>(referent);
	
		assertNotNull(softRerference.get());
		
		referent = null;
		System.gc();
		
		/**
		 *  soft references 只有在 jvm OutOfMemory 之前才会被回收, 所以它非常适合缓存应用
		 */
		assertNotNull(softRerference.get());
	}

4. PhantomReference

作为本文主角， Phantom Reference(幽灵引用) 与 WeakReference 和 SoftReference 有很大的不同, 因为它的 get() 方法永远返回 null, 这也正是它名字的由来

	@Test
	public void phantomReferenceAlwaysNull() {
		Object referent = new Object();
		PhantomReference<Object> phantomReference = new PhantomReference<Object>(referent, new ReferenceQueue<Object>());
		
		/**
		 * phantom reference 的 get 方法永远返回 null 
		 */
		assertNull(phantomReference.get());
	}

         诸位可能要问, 一个永远返回 null 的 reference 要来何用, 请注意构造 PhantomReference 时的第二个参数 ReferenceQueue(事实上 WeakReference & SoftReference 也可以有这个参数)，
PhantomReference 唯一的用处就是跟踪 referent 何时被 enqueue 到 ReferenceQueue 中.

     5. RererenceQueue

当一个 WeakReference 开始返回 null 时，它所指向的对象已经准备被回收，这时可以做一些合适的清理工作.   将一个 ReferenceQueue 传给一个 Reference 的构造函数，当对象被回收时，虚拟机会自动将这个对象插入到 ReferenceQueue 中， WeakHashMap 就是利用 ReferenceQueue 来清除 key 已经没有强引用的 entries.

	@Test
	public void referenceQueue() throws InterruptedException {
		Object referent = new Object();		
		ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
		WeakReference<Object> weakReference = new WeakReference<Object>(referent, referenceQueue);
		
		assertFalse(weakReference.isEnqueued());
		Reference<? extends Object> polled = referenceQueue.poll();
		assertNull(polled);
		
		referent = null;
		System.gc();

		assertTrue(weakReference.isEnqueued());
		Reference<? extends Object> removed = referenceQueue.remove();
		assertNotNull(removed);
	}

6. PhantomReference vs WeakReference

PhantomReference 有两个好处，其一，它可以让我们准确地知道对象何时被从内存中删除，这个特性可以被用于一些特殊的需求中(例如 Distributed GC， XWork 和 google-guice 中也使用 PhantomReference 做了一些清理性工作).

其二，它可以避免 finalization 带来的一些根本性问题, 上文提到 PhantomReference 的唯一作用就是跟踪 referent 何时被 enqueue 到 ReferenceQueue 中, 但是 WeakReference 也有对应的功能, 两者的区别到底在哪呢 ?
这就要说到 Object 的 finalize 方法, 此方法将在 gc 执行前被调用, 如果某个对象重载了 finalize 方法并故意在方法内创建本身的强引用, 这将导致这一轮的 GC 无法回收这个对象并有可能
引起任意次 GC，最后的结果就是明明 JVM 内有很多 Garbage 却 OutOfMemory，使用 PhantomReference 就可以避免这个问题，因为 PhantomReference 是在 finalize 方法执行后回收的，也就意味着此时已经不可能拿到原来的引用, 也就不会出现上述问题, 当然这是一个很极端的例子, 一般不会出现.

7. 对比

taken from http://mindprod.com/jgloss/phantom.html

Soft vs Weak vs Phantom References Type Purpose Use When GCed Implementing Class

Strong Reference	An ordinary reference. Keeps objects alive as long as they are referenced.	normal reference.	Any object not pointed to can be reclaimed.	default
Soft Reference	Keeps objects alive provided there’s enough memory.	to keep objects alive even after clients have removed their references (memory-sensitive caches), in case clients start asking for them again by key.	After a first gc pass, the JVM decides it still needs to reclaim more space.	java.lang.ref.SoftReference
Weak Reference	Keeps objects alive only while they’re in use (reachable) by clients.	Containers that automatically delete objects no longer in use.	After gc determines the object is only weakly reachable	java.lang.ref.WeakReference java.util.WeakHashMap
Phantom Reference	Lets you clean up after finalization but before the space is reclaimed (replaces or augments the use offinalize())	Special clean up processing	After finalization.	java.lang.ref.PhantomReference

8. 小结
一般的应用程序不会涉及到 Reference 编程，但是了解这些知识会对理解 GC 的工作原理以及性能调优有一定帮助, 在实现一些基础性设施比如缓存时也可能会用到，希望本文能有所帮助.

王政于 2009，6，3

分享到：

Spring LoadTimeWeaver 的那些事儿 | Mac OS 10.5.7 严重问题

2009-06-04 03:02
浏览 3307
评论(49)
论坛回复 / 浏览 (44 / 60063)
查看更多

29 楼 maxpana0177 2009-06-09

还是有点不理解啊！

28 楼 jenlp520 2009-06-06

kakaluyi 写道

为什么我们永远用不到的东东，可以被喷精。。。
，难道因为曲高，喷了就说明自己层次高

如果你是自己设计缓存的话这其中还是很使用的

27 楼 kimmking 2009-06-06

zhaomingzm_23 写道

幽灵引用？说真的不看看ref包下的类层次，还真不知道如何使用这些东西。
也许就是摩尔定义的原因吧，所以才出现了ConcurrentHashMap才有了G1

意思是：

使用PhantomReference 不用finalize

可以避免这个问题。

26 楼 zhaomingzm_23 2009-06-06

幽灵引用？说真的不看看ref包下的类层次，还真不知道如何使用这些东西。
也许就是摩尔定义的原因吧，所以才出现了ConcurrentHashMap才有了G1

25 楼 kakaluyi 2009-06-05

为什么我们永远用不到的东东，可以被喷精。。。
，难道因为曲高，喷了就说明自己层次高

24 楼 taowen 2009-06-05

那就不是Concurrent HashMap啦，那是Synchronized的，效率差很远的。

23 楼 Feiing 2009-06-05

taowen 写道

Cache必须基于ConcurrentHashMap吧。貌似你的getTable不能这么简单。。。

ConcurrentHashMap 的 key 并不是用 SoftReference 包装的, 所以要自己实现, 如果需要线程安全, 可以用 Collections.synchroziedMap(new SoftMap()) decorate 一下即可

22 楼 JavaScape 2009-06-05

高人到处有唯有我不是哎 ~。~

21 楼 ansjsun 2009-06-05

赐教了...这些东西在作web开发中会用到么???

20 楼 kaka11 2009-06-05

freej 写道

使用 PhantomReference 就可以避免这个问题，因为 PhantomReference 是在 finalize 方法执行后回收的，也就意味着此时已经不可能拿到原来的引用, 也就不会出现上述问题。

这句话说的有问题吧，不理解、

同问.

19 楼 jenlp520 2009-06-05

taowen 写道

Cache必须基于ConcurrentHashMap吧。貌似你的getTable不能这么简单。。。

缓存基于线程安全上来说还是用ConcurrentHashMap 然后自己在把value用softreference包装下

对于你说那个如果key不在引用了 softreference就不会被清楚
我的想法是这样如果softreference来说如果get为null那么显然对于这个缓存来说他是脏数据了
但是我想了想有2点
1:这个脏数据很小如果数量很少的话几乎可以忽略不计而且如果你在使用缓存的时候做了必要的判断那么这个脏数据也完全不会破坏你的程序
2:这个脏数据应该很少,既然是用在缓存上那么就应该是使用频率很大的那么就象之前我说的

当然这2点也不能完全说明这个脏数据会影响程序的健壮不过有利也有弊还是自己权衡下在使用

ps:如果你愿意定时去遍历缓存然后清理也无妨....

18 楼 matt.u 2009-06-05

恩，讲得很详细，有见地。

不过Java里面这么多种引用方式，对程序员来说还是比较复杂啊。

17 楼 taowen 2009-06-05

Cache必须基于ConcurrentHashMap吧。貌似你的getTable不能这么简单。。。

16 楼 Feiing 2009-06-04

taowen 写道

Feiing 写道

taowen 写道

如果我用一个ConcurrentHashMap<String, SoftReference>来持有我的Cache。那么我是应该是Finalizer呢还是ReferenceQueue来把SoftReference从cache中清除出去？目的就是把缓存尽可能长的时间持有，除非内存不够了。

应该用 ReferenceQueue 来实现, 可以参考 WeakHashMap 的实现, 另外缓存类型应该是 ConcurrentHashMap<SoftReference, Object>, 因为清除的依据肯定是 key 而非 value

Key如果是SoftReference，那我怎么取我的cache啊？

说错了, 应该是 key 应该被包装成 SoftReference, 代码大致会是这样 (事实上 WeakHashMap 就是这样实现的)


public class SoftHashMap<K, V> {
   
    /**
     * 用于清理无效 entries
     */
    private final ReferenceQueue<K> queue = new ReferenceQueue<K>();

    public V put(K key, V value) {

     ...
     new SoftEntry(key, value, queue);
     ...

    }

    public V get(K key) {
        int h = HashMap.hash(key.hashCode());
        Entry[] tab = getTable();
        int index = indexFor(h, tab.length);
        Entry<K,V> e = tab[index];
        while (e != null) {
            if (e.hash == h && eq(key, e.get()))
                return e.value;
            e = e.next;
        }
        return null;
    }
    
    /**
     * Returns the table after first expunging stale entries.
     */
    private Entry[] getTable() {
        expungeStaleEntries();
        return table;
    }
    
    /**
     *  清理无用 entries
     */
    private void expungeStaleEntries() {
	Entry<K,V> e;
        while ( (e = (Entry<K,V>) queue.poll()) != null) {
           remove e;
        }
    }


    private static final class SoftEntry<K, V> extends SoftReference<K> implements Map.Entry<K, V> {
      
      private V value;
      
      public SoftEntry(K key, V value, ReferenceQueue<K> queue) {
          super(key, queue);
          this.value = value;
      }

 
       public K getKey() {
           return get();
       }

       public V getValue() {
           return this.value;
       }

    }

}

15 楼 magnesium 2009-06-04

不错不错，又学会了点东西

14 楼 taowen 2009-06-04

jenlp520 写道

taowen 写道

jenlp520 写道

taowen 写道

应该是这样如果你Sofrreference里面引用的对象没有别的引用的时候在每次内存溢出前就会被自动清理掉

Object -> SoftReference -> Map
SoftReference对Object的引用会自动断开。但是SoftReference本身还会在Map中存在一个Entry。如何做到内存溢出的时候自动把SoftReference从Map中移除呢？

你用softReference来做缓存主要目的是为了长期持有对象而不引起内存泄露那个对象自然就是被softReference引用的
既然在内存泄露前你的大对象已经被清理了你的这次危机自然就解除了等你下一次用这个大对象的时候你会发现softReference的get()是null了那么你是不是会重新put一个新的进去呢
于是你上次的softReference会在下次gc调用的时候被清理掉了...

如果这个key再也不被引用了，就永远不会被清除了。这算不算是Memory Leak呢？

13 楼 taowen 2009-06-04

Feiing 写道

taowen 写道

应该用 ReferenceQueue 来实现, 可以参考 WeakHashMap 的实现, 另外缓存类型应该是 ConcurrentHashMap<SoftReference, Object>, 因为清除的依据肯定是 key 而非 value

Key如果是SoftReference，那我怎么取我的cache啊？

12 楼 jenlp520 2009-06-04

taowen 写道

jenlp520 写道

taowen 写道

应该是这样如果你Sofrreference里面引用的对象没有别的引用的时候在每次内存溢出前就会被自动清理掉

11 楼 Feiing 2009-06-04

taowen 写道

应该用 ReferenceQueue 来实现, 可以参考 WeakHashMap 的实现, 另外缓存类型应该是 ConcurrentHashMap<SoftReference, Object>, 因为清除的依据肯定是 key 而非 value

10 楼 taowen 2009-06-04

jenlp520 写道

taowen 写道

应该是这样如果你Sofrreference里面引用的对象没有别的引用的时候在每次内存溢出前就会被自动清理掉

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论