JVM深入学习(十五)-深入了解java引用

packagejava.lang.ref;
importjdk.internal.vm.annotation.ForceInline;
importjdk.internal.vm.annotation.IntrinsicCandidate;
importjdk.internal.access.JavaLangRefAccess;
importjdk.internal.access.SharedSecrets;
importjdk.internal.ref.Cleaner;
/*** Abstract base class for reference objects.  This class defines the* operations common to all reference objects.  Because reference objects are* implemented in close cooperation with the garbage collector, this class may* not be subclassed directly.** @author   Mark Reinhold* @since    1.2*/publicabstractclassReference<T> {
    ...
}

publicclassTest1 {
publicstaticvoidmain(String[] args) {
Stringstr=newString("hello world");
// 垃圾回收System.gc();
// 线程休眠3s,等待gc完成try {
Thread.sleep(3000);
        } catch (InterruptedExceptione) {
e.printStackTrace();
        }
// 如果能打印,就说明没被回收System.out.print(str);
    }
}

packagejava.lang.ref;
/*** Soft reference objects, which are cleared at the discretion of the garbage* collector in response to memory demand.  Soft references are most often used* to implement memory-sensitive caches.** <p> Suppose that the garbage collector determines at a certain point in time* that an object is <a href="package-summary.html#reachability">softly* reachable</a>.  At that time it may choose to clear atomically all soft* references to that object and all soft references to any other* softly-reachable objects from which that object is reachable through a chain* of strong references.  At the same time or at some later time it will* enqueue those newly-cleared soft references that are registered with* reference queues.** <p> All soft references to softly-reachable objects are guaranteed to have* been cleared before the virtual machine throws an* {@code OutOfMemoryError}.  Otherwise no constraints are placed upon the* time at which a soft reference will be cleared or the order in which a set* of such references to different objects will be cleared.  Virtual machine* implementations are, however, encouraged to bias against clearing* recently-created or recently-used soft references.** <p> Direct instances of this class may be used to implement simple caches;* this class or derived subclasses may also be used in larger data structures* to implement more sophisticated caches.  As long as the referent of a soft* reference is strongly reachable, that is, is actually in use, the soft* reference will not be cleared.  Thus a sophisticated cache can, for example,* prevent its most recently used entries from being discarded by keeping* strong referents to those entries, leaving the remaining entries to be* discarded at the discretion of the garbage collector.** @author   Mark Reinhold* @since    1.2*/publicclassSoftReference<T>extendsReference<T> {
...
}

importjava.lang.ref.SoftReference;
publicclassSoftReferenceTest {
publicstaticvoidmain(String[] args) {
// 创建一个软引用 hello_world 关联了一个强引用对象String,当然这个对象创建完就不可达了,会被回收掉,// 此时我们还能否从软引用中获取该对象?SoftReferencehello_world=newSoftReference(newString("hello world"));
// 确定可以通过软引用获取StringSystem.out.println(hello_world.get().toString());
// 接下来设置堆内存大小为 -Xms10M -Xmx10M -XX:+PrintGCDetails// 并触发垃圾回收// 进行异常捕获,最后输出软引用try {
byte[] bytes=newbyte[1024*1024*10];
        }catch (Exceptione){
e.printStackTrace();
        }finally {
System.out.println("垃圾回收后");
System.out.println(hello_world.get());
        }
    }
}

packagejava.lang.ref;
/*** Weak reference objects, which do not prevent their referents from being* made finalizable, finalized, and then reclaimed.  Weak references are most* often used to implement canonicalizing mappings.** <p> Suppose that the garbage collector determines at a certain point in time* that an object is <a href="package-summary.html#reachability">weakly* reachable</a>.  At that time it will atomically clear all weak references to* that object and all weak references to any other weakly-reachable objects* from which that object is reachable through a chain of strong and soft* references.  At the same time it will declare all of the formerly* weakly-reachable objects to be finalizable.  At the same time or at some* later time it will enqueue those newly-cleared weak references that are* registered with reference queues.** @author   Mark Reinhold* @since    1.2*/publicclassWeakReference<T>extendsReference<T> {
...
}

importjava.lang.ref.WeakReference;
importjava.util.WeakHashMap;
publicclassWeakReferenceTest {
publicstaticvoidmain(String[] args) {
WeakReferenceweakReference=newWeakReference<>(newString("hello world"));
System.out.println(weakReference.get());
System.gc();
try {
Thread.sleep(3000);
        } catch (InterruptedExceptione) {
e.printStackTrace();
        }
System.out.println("垃圾回收后");
System.out.println(weakReference.get());
    }
}

packagejava.lang.ref;
importjdk.internal.vm.annotation.IntrinsicCandidate;
/*** Phantom reference objects, which are enqueued after the collector* determines that their referents may otherwise be reclaimed.  Phantom* references are most often used to schedule post-mortem cleanup actions.** <p> Suppose the garbage collector determines at a certain point in time* that an object is <a href="package-summary.html#reachability">* phantom reachable</a>.  At that time it will atomically clear* all phantom references to that object and all phantom references to* any other phantom-reachable objects from which that object is reachable.* At the same time or at some later time it will enqueue those newly-cleared* phantom references that are registered with reference queues.** <p> In order to ensure that a reclaimable object remains so, the referent of* a phantom reference may not be retrieved: The {@code get} method of a* phantom reference always returns {@code null}.* The {@link #refersTo(Object) refersTo} method can be used to test* whether some object is the referent of a phantom reference.** @author   Mark Reinhold* @since    1.2*/publicclassPhantomReference<T>extendsReference<T> {
...
}

importjava.lang.ref.PhantomReference;
importjava.lang.ref.Reference;
importjava.lang.ref.ReferenceQueue;
publicclassPhantomReferenceTest {
staticReferenceQueuereferenceQueue=null;
/*** 守护线程,监听queue队列,当有虚引用被回收时,就可以看到输出哪个对象被回收了*/publicstaticclassCheckGcThreadextendsThread {
@Overridepublicvoidrun() {
if (referenceQueue!=null) {
Referenceremove=null;
try {
remove=referenceQueue.remove();
                } catch (InterruptedExceptione) {
e.printStackTrace();
                }
if (remove!=null) {
System.out.println(remove+"对象被回收了");
                }
            }
        }
    }
publicstaticvoidmain(String[] args) {
// 启动队列监听线程  设置为守护线程,当主线程结束的时候随之结束CheckGcThreadcheckGcThread=newCheckGcThread();
checkGcThread.setDaemon(true);
checkGcThread.start();
// 虚引用的创建必须要传入一个队列referenceQueue=newReferenceQueue();
PhantomReferencehello_world=newPhantomReference(newString("hello"+" world"), referenceQueue);
// 无法通过虚引用获取对象的值System.out.println(hello_world.get());
// 垃圾回收System.gc();
    }
}

packagejava.lang.ref;
/*** Final references, used to implement finalization*/classFinalReference<T>extendsReference<T> {
...
}