java 解析 xml jab2,Java引用详解

1 Java中的四种引用

在Java中提供了四个级别的引用：强引用，软引用，弱引用和虚引用。在这四个引用类型中，只有强引用FinalReference类是包内可见，其他三种引用类型均为public，可以在应用程序中直接使用。引用类型的类结构如图所示。

1.1 强引用

Java中的强引用指的是，程序中有直接可达的引用。如

Object obj = new Object();

强引用的特点：

强引用可以直接访问目标对象。

强引用所指向的对象在任何时候都不会被系统回收。JVM宁愿抛出OOM异常，也不会回收强引用所指向的对象。

强引用可能导致内存泄漏。

1.2 软引用

软引用是除了强引用外，最强的引用类型。可以通过java.lang.ref.SoftReference使用软引用。

SoftReference softRef = new SoftReference(new Object());

软引用的特点：

1.软引用的对象，只有在内存不足的时候(抛出OOM异常前)，垃圾收集器会决定回收该软引用所指向的对象。软引用通常用于实现内存敏感的缓存。

2.在垃圾线程对 这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之后，get()方法将返回null。

1.3 弱引用

弱引用是一种比软引用较弱的引用类型。可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。

WeakReference weakRef = new WeakReference(new Object());

软引用的特点：

1.不管内存是否足够，只要被垃圾收集器发现，该引用的对象就会被回收

1.4 虚引用

虚引用是所有类型中最弱的一个。一个持有虚引用的对象，和没有引用几乎是一样的，可以用java.lang.ref.WeakReference实例来保存对一个Java对象的弱引用。

Object obj = new Object();

ReferenceQueue refQueue = new ReferenceQueue<>();

PhantomReference phantom = new PhantomReference(obj, refQueue);

虚引用的特点：

1.随时可能被垃圾回收器回收。

2.当试图通过虚引用的get()方法取得强引用时，总是返回null。

3.虚引用必须和引用队列一起使用。

当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在垃圾回收后，销毁这个对象，将这个虚引用加入引用队列。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。

2 ReferenceQueue

引用队列，当检测到对象的可到达性更改时，垃圾回收器将已注册的引用对象添加到队列中，ReferenceQueue实现了入队(enqueue)和出队(poll)，还有remove操作，内部元素head就是泛型的Reference。

//创建一个引用队列

ReferenceQueue queue = new ReferenceQueue();

// 创建弱引用，此时状态为Active，并且Reference.pending为空，当前Reference.queue = 上面创建的queue，并且next=null

WeakReference reference = new WeakReference(new Object(), queue);

System.out.println(reference);

// 当GC执行后，由于是弱引用，所以回收该object对象，并且置于pending上，此时reference的状态为PENDING

System.gc();

/* ReferenceHandler从pending中取下该元素，并且将该元素放入到queue中，此时Reference状态为ENQUEUED，Reference.queue = ReferenceENQUEUED */

/* 当从queue里面取出该元素，则变为INACTIVE，Reference.queue = Reference.NULL */

Reference reference1 = queue.remove();

System.out.println(reference1);

3 源码分析

3.1Reference定义的4种状态

Reference类首先把内存分为4种状态Active，Pending，Enqueued，Inactive。

Active，一般来说内存一开始被分配的状态都是 Active，

Pending 大概是指快要被放进队列的对象，也就是马上要回收的对象，

Enqueued 就是对象的内存已经被回收了，我们已经把这个对象放入到一个队列中，方便以后我们查询某个对象是否被回收，

Inactive就是最终的状态，不能再变为其它状态。

3.2 Reference成员变量

// 用于保存对象的引用，GC会根据不同Reference来特别对待

private T referent;

// 如果需要通知机制，则保存的对对应的队列

ReferenceQueue super T> queue;

/* 这个用于实现一个单向循环链表，用以将保存需要由ReferenceHandler处理的引用 */

Reference next;

static private class Lock { };

// 锁，用于同步pending队列的进队和出队

private static Lock lock = new Lock();

transient private Reference discovered; /* used by VM */

// 此属性保存一个PENDING的队列，配合上述next一起使用

private static Reference pending = null;

referent表示其引用的对象，即在构造的时候需要被包装在其中的对象。

queue 是对象即将被回收时所要通知的队列。当对象即将被回收时，整个reference对象，而不仅仅是被回收的对象，会被放到queue 里面，然后外部程序即可通过监控这个 queue 即可拿到相应的数据了。

next 即当前引用节点所存储的下一个即将被处理的节点。但 next 仅在放到queue中才会有意义，因为只有在enqueue的时候，会将next设置为下一个要处理的Reference对象。为了描述相应的状态值，在放到队列当中后，其queue就不会再引用这个队列了。而是引用一个特殊的 ENQUEUED(内部定义的一个空队列)。因为已经放到队列当中，并且不会再次放到队列当中。

discovered 表示要处理的对象的下一个对象。即可以理解要处理的对象也是一个链表，通过discovered进行排队，这边只需要不停地拿到pending，然后再通过discovered 不断地拿到下一个对象赋值给pending即可，直到取到了最有一个。它是被JVM 使用的。

pending 是等待被入队的引用列表。JVM 收集器会添加引用到这个列表，直到Reference-handler线程移除了它们。这个列表使用 discovered 字段来连接它下一个元素(即 pending 的下一个元素就是discovered对象。r = pending; pending = r.discovered)。

3.3 ReferenceQueue成员变量

// 用于标识没有注册Queue

static ReferenceQueue NULL = new Null();

// 用于标识已经处于对应的Queue中

static ReferenceQueue ENQUEUED = new Null();

static private class Lock { };

/* 互斥锁，用于同步ReferenceHandler的enqueue和用户线程操作的remove和poll出队操作 */

private Lock lock = new Lock();

// 队列

private volatile Reference extends T> head = null;

// 队列中的元素个数

private long queueLength = 0;

3.4 对象的入队过程

当 Reference 类被加载的时候，会执行静态代码块。在静态代码块里面，会启动 ReferenceHandler 线程,并设置线程的级别为最大级别， Thread.MAX_PRIORITY。

检查 pending 是否为 null，如果pending不为 null，则将 pending 进行 enqueue，否则线程进入 wait 状态。

private static class ReferenceHandler extends Thread {

----- // 核心代码如下

public void run() {

while (true) {

tryHandlePending(true);

}

}

static boolean tryHandlePending(boolean waitForNotify) {

Reference r;

Cleaner c;

try {

synchronized (lock) {

// 检查 pending 是否为 null，不为 null，制定 pending enqueue

if (pending != null) {

r = pending;

// 'instanceof' might throw OutOfMemoryError sometimes

// so do this before un-linking 'r' from the 'pending' chain...

c = r instanceof Cleaner ? (Cleaner) r : null;

// unlink 'r' from 'pending' chain

pending = r.discovered;

r.discovered = null;

} else { // 为 null。等待

// The waiting on the lock may cause an OutOfMemoryError

// because it may try to allocate exception objects.

if (waitForNotify) {

lock.wait();

}

// retry if waited

return waitForNotify;

}

}

} catch (OutOfMemoryError x) {

// Give other threads CPU time so they hopefully drop some live references

// and GC reclaims some space.

// Also prevent CPU intensive spinning in case 'r instanceof Cleaner' above

// persistently throws OOME for some time...

Thread.yield();

// retry

return true;

} catch (InterruptedException x) {

// retry

return true;

}

// Fast path for cleaners

if (c != null) {

c.clean();

return true;

}

ReferenceQueue super Object> q = r.queue;

if (q != ReferenceQueue.NULL) q.enqueue(r);

return true;

}

}

/******************************ReferenceQueue*************************/

boolean enqueue(Reference extends T> r) { /* Called only by Reference class */

synchronized (lock) {

// Check that since getting the lock this reference hasn't already been

// enqueued (and even then removed)

ReferenceQueue> queue = r.queue;

// queue 为 null 或者 queue 已经被回收了，直接返回

if ((queue == NULL) || (queue == ENQUEUED)) {

return false;

}

assert queue == this;

// 将 Reference 的状态置为 Enqueued，表示已经被回收

r.queue = ENQUEUED;

// 接着，将 Reference 插入到链表

// 判断当前链表是否为 null，不为 null，将 r.next 指向 head，为 null，head 直接指向 r

r.next = (head == null) ? r : head;

// head 指针指向 r

head = r;

queueLength++;

if (r instanceof FinalReference) {

sun.misc.VM.addFinalRefCount(1);

}

lock.notifyAll();

return true;

}

}

注意：

JVM在GC时会把回收了内存的对象的'Reference'通过'discovered'连接成链表。

‘pending’属性相对于'discovered'链表上面的指针，每次把当前的元素放入引用队列，然后指向链表的下一个元素。

'Reference'的'next'属于用于指向一个已经在队列中被回收的对象。

4 Object的finalize()方法原理

4.1 finalize()方法简介

如果一个类实现了finalize方法，那么GC在回收这个对象之前，会将finalize方法进行调用。finalize的一般约定是，jvm虚拟机已经确定没有任何引用或者线程访问此对象，就会调用这个finalize方法。在finalize方法中可以进行任何操作，包括该对象再次对其他线程进行调用。这个方法的目的是在gc回收对象之前，再次对之前未关闭的资源进行回收。如IO操作中的连接等。

java虚拟机并不保证哪个线程会具体调用finalize方法，但是可以保证调用finalize方法的时候不会有任何用户可见的同步锁。如果finalize方法中出现任何异常，则这些异常会被忽略，且finalize方法会终止。

在一个对象调用finalize方法之后，在jvm确认这个对象没有任何其他对象能访问之前，也就是说jvm确认这个对象不是垃圾之前。finalize方法不会执行。

finalize 方法只会被虚拟机执行一次。

finalize方法中的异常会被忽略，之后finalize方法会终止。

4.2 FinalReference

FinalReference的实现非常简单，这个类不是public的，其作用域在protected，也就是说除了java.lang.ref包中的类能访问之外，不能在任何自定义的代码中调用。这也说明这是一个jvm才能访问的类。

class FinalReference extends Reference {

public FinalReference(T referent, ReferenceQueue super T> q) {

super(referent, q);

}

}

4.3 Finalizer

Finalizer是finalReference的子类，对queue和lock进行了重写。Finalizer也是protected作用域，另外通过final修饰。不可被继承。

//final修饰的类不可被继承

final class Finalizer extends FinalReference {

//重写了queue属性，Finalizer必须使用ReferenceQueue,因此一开始就对queue进行了实例化

private static ReferenceQueue queue = new ReferenceQueue<>();

private static Finalizer unfinalized = null;

//重载了锁

private static final Object lock = new Object();

//链表指针，Finalizer是个双向链表

private Finalizer

next = null,

prev = null;

}

4.4 FinalizerThread

jvm在注册的时候，实际上就是创建了一个Finalizer的链表。在GC的时候，如果发现对象只被Finalizer引用，则说明这个对象可以被回收了。那么就将其从引用对象链中取出，放入ReferenceQueue中。之后通知Finalizer Thread线程去消费。之后去调用finalize方法。

private static class FinalizerThread extends Thread {

private volatile boolean running;

FinalizerThread(ThreadGroup g) {

super(g, "Finalizer");

}

public void run() {

if (running)

return;

// Finalizer thread starts before System.initializeSystemClass

// is called. Wait until JavaLangAccess is available

while (!VM.isBooted()) {

// delay until VM completes initialization

try {

VM.awaitBooted();

} catch (InterruptedException x) {

// ignore and continue

}

}

final JavaLangAccess jla = SharedSecrets.getJavaLangAccess();

running = true;

for (;;) {

try {

Finalizer f = (Finalizer)queue.remove();

f.runFinalizer(jla);

} catch (InterruptedException x) {

// ignore and continue

}

}

}

}

/*********************************Finalizer****************************/

private void runFinalizer(JavaLangAccess jla) {

synchronized (this) {

if (hasBeenFinalized()) return;

remove();

}

try {

Object finalizee = this.get();

if (finalizee != null && !(finalizee instanceof java.lang.Enum)) {

jla.invokeFinalize(finalizee);

/* Clear stack slot containing this variable, to decrease

the chances of false retention with a conservative GC */

finalizee = null;

}

} catch (Throwable x) { }

super.clear();

}

流程：

在创建对象的时候，如果重写了finalize方法，jvm就会同时创建一个Finalizer对象。

所有的Finalizer对象构成一个双向链表

所有的Finalizer对象都有一个名为queue的ReferenceQueue队列

GC在执行标记的最后阶段，会把Finalizer的对象加入到Reference的pending-list 链表中。

ReferenceHandler会将pending-list中的对象取出，放置到这个ReferenceQueue中。对于finalReference而言，这个queue即使初始化的时候创建的static的queue。对于所有的FinalReference全局只有一个ReferenceQueue。

Finalizer中有一个专门的守护线程 Finalizer Thread,这个线程中有一个死循环，专门从queue中取出对象，并执行Finalizer中引用对象的finalize方法。之后从队列中移除，强引用消除。

再次GC 这个Finalizer的对象没有任何引用，因此可能被回收掉。