Chinaunix首页 | 论坛 | 博客
  • 博客访问: 334333
  • 博文数量: 95
  • 博客积分: 2030
  • 博客等级: 大尉
  • 技术积分: 738
  • 用 户 组: 普通用户
  • 注册时间: 2006-08-12 09:11
文章分类

全部博文(95)

文章存档

2018年(4)

2017年(16)

2016年(61)

2015年(1)

2013年(3)

2006年(10)

我的朋友

分类: Java

2018-01-19 15:08:29

1 何为ReferenceQueue

在java的引用体系中,存在着强引用,软引用,虚引用,幽灵引用,这4种引用类型。在正常的使用过程中,我们定义的类型都是强引用的,这种引用类型在回收中,只有当其它对象没有对这个对象的引用时,才会被GC回收掉。简单来说,对于以下定义:

1
2
Object obj = new Object();
Ref ref = new Ref(obj);

在这种情况下,如果ref没有被GC,那么obj这个对象肯定不会GC的。因为ref引用到了obj。如果obj是一个大对象呢,多个这种对象的话,应用肯定一会就挂掉了。

那么,如果我们希望在这个体系中,如果obj没有被其它对象引用,只是在这个Ref中存在引用时,就把obj对象gc掉。这时候就可以使用这里提到的Reference对象了。

我们希望当一个对象被gc掉的时候通知用户线程,进行额外的处理时,就需要使用引用队列了。ReferenceQueue即这样的一个对象,当一个obj被gc掉之后,其相应的包装类,即ref对象会被放入queue中。我们可以从queue中获取到相应的对象信息,同时进行额外的处理。比如反向操作,数据清理等。

2 使用队列进行数据监控

一个简单的例子,通过往map中放入10000个对象,每个对象大小为1M字节数组。使用引用队列监控被放入的key的回收情况。代码如下所示:

 

1
2
3
4
5
6
7
8
Object value = new Object();
Map map = new HashMap<>();
for(int i = 0;i < 10000;i++) {
    byte[] bytes = new byte[_1M];
    WeakReference weakReference = new WeakReference(bytes, referenceQueue);
    map.put(weakReference, value);
}
System.out.println("map.size->" + map.size());

这里使用了weakReference对象,即当值不再被引用时,相应的数据被回收。另外使用一个线程不断地从队列中获取被gc的数据,代码如下:

01
02
03
04
05
06
07
08
09
10
11
12
13
Thread thread = new Thread(() -> {
    try {
        int cnt = 0;
        WeakReference k;
        while((k = (WeakReference) referenceQueue.remove()) != null) {
            System.out.println((cnt++) + "回收了:" + k);
        }
    } catch(InterruptedException e) {
        //结束循环
    }
});
thread.setDaemon(true);
thread.start();

结果如下所示:

1
2
3
4
5
9992回收了:java.lang.ref.WeakReference@1d13cd4
9993回收了:java.lang.ref.WeakReference@118b73a
9994回收了:java.lang.ref.WeakReference@1865933
9995回收了:java.lang.ref.WeakReference@ad82c
map.size->10000

在这次处理中,map并没有因为不断加入的1M对象由产生OOM异常,并且最终运行结果之后map中的确有1万个对象。表示确实被放入了相应的对象信息。不过其中的key(即weakReference)对象中的byte[]对象却被回收了。即不断new出来的1M数组被gc掉了。

从命令行中,我们看到有9995个对象被gc,即意味着在map的key中,除了weakReference之外,没有我们想要的业务对象。那么在这样的情况下,是否意味着这9995个entry,我们认为就是没有任何意义的对象,那么是否可以将其移除掉呢。同时还期望size值可以打印出5,而不是10000.
WeakHashMap就是这样的一个类似实现。

3 在类weakHashMap中的使用

weakHashMap即使用weakReference当作key来进行数据的存储,当key中的引用被gc掉之后,它会自动(类似自动)的方式将相应的entry给移除掉,即我们会看到size发生了变化。

从简单来看,我们认为其中所有一个类似的机制从queue中获取引用信息,从而使得被gc掉的key值所对应的entry从map中被移除。这个处理点就在我们调用weakhashmap的各个处理点中,比如get,size,put等。简单点来说,就是在调用get时,weakHashMap会先处理被gc掉的key值,然后再处理我们的业务调用。

简单点代码如下:

1
2
3
4
5
6
public int size() {
    if (size == 0)
        return 0;
    expungeStaleEntries();
    return size;
}

此处的expungeStaleEntries即移除方法,具体的逻辑可以由以下的流程来描述:

  • A:使用一个继承于WeakReference的entry对象表示每一个kv对,其中的原引用对象即我们在放入map中的key值
  • B:为保证效率以及尽可能的不使用key值,hash经过预先计算。这样在定位数据及重新get时不再需要使用原引用对象
  • C:由queue拿到的事件对象,即这里的entry值。通过entry定位到具体的桶位置,通过链表计算将entry的前后重新连接起来(即p.pre.next = p.next)

因此,这里的引用处理并不是自动的,其实是我们在调用某些方法的时候处理,所以我们认为它不是一种自动的,只是表面上看起来是这种处理。
具体的代码,即将开始的map定义为一个WeakHashMap,最终的输出类似如下所示:

1
2
3
4
9993回收了:java.lang.ref.WeakReference@12aa816
9994回收了:java.lang.ref.WeakReference@2bd967
9995回收了:java.lang.ref.WeakReference@13e9593
weakHashMap.size->4

在上面的代码中,由于weakhashmap不允许自定义queue,所以上面的监控是针对value的。在weakHashMap中,queue在weakhashmap在内部定义,并且由内部消化使用了。如果我们在自己进一步处理,那就只能自定义类似weakHashMap实现,或者使用反向操作。即在监控到变化之后,自己处理map的kv。

4 队列监控的反向操作

反向操作,即意味着一个数据变化了,可以通过weakReference对象反向拿相关的数据,从而进行业务的处理。比如,我们可以通过继承weakReference对象,加入自定义的字段值,额外处理。一个类似weakHashMap如下,这时,我们不再将key值作为弱引用处理,而是封装在weakReference对象中,以实现额外的处理。

WeakR对象定义如下:

1
2
3
4
5
6
7
8
9
//描述一种强key关系的处理,当value值被回收之后,我们可以通过反向引用将key从map中移除的做法
//即通过在weakReference中加入其所引用的key值,以获取key信息,再反向移除map信息
class WeakR extends WeakReference {
    private Object key;
    WeakR(Object key, byte[] referent, ReferenceQueue q) {
        super(referent, q);
        this.key = key;
    }
}

那么,相应的map,我们就使用普通的hashMap,将weakR作为value进行存储,如下所示:

1
2
3
4
5
6
final Map hashMap = new HashMap<>();
for(int i = 0;i < 10000;i++) {
            byte[] bytesKey = new byte[_1M];
            byte[] bytesValue = new byte[_1M];
            hashMap.put(bytesKey, new WeakR(bytesKey, bytesValue, referenceQueue));
        }

相应的队列,我们则一样地进行监控,不同的是,我们对获取的WeakR对象进行了额外的处理,如下所示:

1
2
3
4
5
6
7
8
int cnt = 0;
                    WeakR k;
                    while((k = (WeakR) referenceQueue.remove()) != null) {
                        System.out.println((cnt++) + "回收了:" + k);
                        //触发反向hash remove
                        hashMap.remove(k.key);
                        //额外对key对象作其它处理,比如关闭流,通知操作等
                    }

其实就是拿到反向引用的key值(这里的value已经不存在了),因为kv映射已没有意义,将其从map中移除掉。同时,我们还可以作其它的操作(具体的操作还没想到,嘿嘿)

这个也可以理解为就是一个类似cache的实现。
在cache中,key不重要并且通常都很少,value才是需要对待的。这里通过监控value变化,反向修改map,以达到控制kv的目的,避免出现无用的kv映射。

相应的输出,如下所示:

1
2
3
4
9995回收了:com.m_ylf.study.java.reference.TestCase$1WeakR@13c5f83
9996回收了:com.m_ylf.study.java.reference.TestCase$1WeakR@197558c
9997回收了:com.m_ylf.study.java.reference.TestCase$1WeakR@164bc7e
hashMap.size->1

5 在google guava的简单描述

在google guava中,实现了一个类似在第4中所对应的操作。同时对于反向操作,通过继承一个指定的对象(可以理解为weakReference和callback的组合对象),当value值被gc之后,即可以直接在回调中处理业务即可,不需要自己来监控queue。(见FinalizableReference)

阅读(145) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册