Java en un total de cuatro tipos de tipos de referencia (de hecho, hay algunos otros tipos de referencia como FinalReference): referencias fuertes, suaves referencias, referencias débiles, referencias fantasma.
En el que la referencia fuerte que a menudo el uso de objetos a = new Object (); esta forma, y no en la clase Java correspondiente referencia.
Este artículo es analizar la suave, débil, cita, implementar referencia virtual, tres tipos de referencia se heredan de la clase de referencia, la lógica principal también referencia.
problema
Antes del análisis, antes de lanzar un par de preguntas?
1. La mayor parte del artículo en línea para introducir la referencia es suave: se reciclará en la memoria del tiempo, de que no hay suficiente memoria se define cómo? Lo que se quiere decir con suficiente memoria?
2. La mayor parte del artículo en línea para introducir la referencia Phantom es: inútil, colgando de referencia y no determina el ciclo de vida del objeto. Se utiliza principalmente para rastrear objetos recuperados actividad recolector de basura. ¿Es realmente?
3. referencia fantasma en las que se ha utilizado en la escena en Jdk?
Referencia
Nos fijamos en Reference.java en varios campos
public abstract class Reference<T> {
//引用的对象
private T referent;
//回收队列，由使用者在Reference的构造函数中指定
volatile ReferenceQueue<? super T> queue;
//当该引用被加入到queue中的时候，该字段被设置为queue中的下一个元素，以形成链表结构
volatile Reference next;
//在GC时，JVM底层会维护一个叫DiscoveredList的链表，存放的是Reference对象，discovered字段指向的就是链表中的下一个元素，由JVM设置
transient private Reference<T> discovered;
//进行线程同步的锁对象
static private class Lock { }
private static Lock lock = new Lock();
//等待加入queue的Reference对象，在GC时由JVM设置，会有一个java层的线程(ReferenceHandler)源源不断的从pending中提取元素加入到queue
private static Reference<Object> pending = null;objeto de referencia de un ciclo de vida de la siguiente manera:
Se divide en dos partes capas y capas de Java nativos.
necesitará Native la capa de GC para ser añadido a la recuperado DiscoveredList en el objeto de referencia (el código referenceProcessor.cpp método process_discovered_references), y luego mover la DiscoveredList elemento a PendingList (código referenceProcessor.cpp el método enqueue_discovered_ref_helper), el equipo PendingList referencia es de primera clase en los objetos pendientes.
Mira la capa de código de Java
El proceso es relativamente simple: que se extrae de un flujo constante de PendingList a cabo elemento, y luego agregarlo a ir ReferenceQueue, los desarrolladores pueden percibir desde el elemento de sondeo ReferenceQueue al objeto a ser eventos recuperados.
Tenga en cuenta también que para el tipo Cleaner (heredado de referencia phantom) objeto tendrá un procesamiento adicional: cuando apunta a un objeto se recupera, se llamará el método limpia, que se utiliza principalmente para el reciclaje correspondiente, en memoria externa en el montón se recupera fuera de la memoria DirectByteBuffer montón con Cleaner, que es una aplicación típica en java referencia virtual.
Después de leer la realización de referencia, y la mirada después a unos pocos alcanzar la clase, cada uno de los cuales tiene diferente.
SoftReference
Lograr una referencia suave es muy simple, el más los dos campos: el reloj y marca de tiempo. reloj es una variable estática, el campo se establece en la hora actual cada vez que el GC. campo de marca de tiempo obtendrá en cada llamada al método correspondiente con un reloj (si no es igual a la meta no se ha recuperado).
¿Cuál es el papel que estos dos campos es? Sólo se recuperó en las referencias suaves y la memoria insuficiente cuando, ¿qué importa?
La JVM tendrá que ver el código fuente para el trabajo, ya que el objeto necesita ser decidido si la recuperación se lleva a cabo en el GC.
refs_lists almacenados en un cierto tipo de referencia encontraron en este GC (referencia fantasma, blandos, débiles, referencias, etc.), método process_discovered_reflist actuando es eliminar los objetos no necesitan ser recuperados de elemento de la fuera refs_lists, refs_lists últimos restante todos los elementos tienen que ser recuperados, y los lugares del primer elemento se le asigna al campo pendientes antes mencionado Reference.java #.
ReferencePolicy conseguir un total de cuatro tipos: NeverClearPolicy, AlwaysClearPolicy, LRUCurrentHeapPolicy, LRUMaxHeapPolicy.
NeverClearPolicy que siempre devuelve falso, representantes nunca se recuperaron SoftReference, no se utiliza en la clase JVM, AlwaysClearPolicy nunca se volverá verdad, en el proceso de referenceProcessor.hpp # configuración puede ser la política de ajuste para el AlwaysClearPolicy, en cuanto a cuándo se va a utilizar AlwaysClearPolicy, estamos interesados pueden estudiar por su cuenta.
LRUCurrentHeapPolicy和LRUMaxHeapPolicy的should_clear_reference方法则是完全相同：
timestamp_clock就是SoftReference的静态字段clock，java_lang_ref_SoftReference::timestamp(p)对应是字段timestamp。如果上次GC后有调用SoftReference#get，interval值为0，否则为若干次GC之间的时间差。
_max_interval则代表了一个临界值，它的值在LRUCurrentHeapPolicy和LRUMaxHeapPolicy两种策略中有差异
其中SoftRefLRUPolicyMSPerMB默认为1000，前者的计算方法和上次GC后可用堆大小有关，后者计算方法和（堆大小-上次gc时堆使用大小）有关。
看到这里你就知道SoftReference到底什么时候被被回收了，它和使用的策略（默认应该是LRUCurrentHeapPolicy），堆可用大小，该SoftReference上一次调用get方法的时间都有关系。
WeakReference
可以看到WeakReference在Java层只是继承了Reference，没有做任何的改动。那referent字段是什么时候被置为null的呢？要搞清楚这个问题我们再看下上文提到过的process_discovered_reflist方法：
不管是弱引用还是其他引用类型，将字段referent置null的操作都发生在process_phase3中，而具体行为是由clear_referent的值决定的。而clear_referent的值则和引用类型相关。
可以看到，对于Soft references和Weak references clear_referent字段传入的都是true，这也符合我们的预期：对象不可达后，引用字段就会被置为null，然后对象就会被回收（对于软引用来说，如果内存足够的话，在Phase 1，相关的引用就会从refs_list中被移除，到Phase 3时refs_list为空集合）。
但对于Final references和 Phantom references，clear_referent字段传入的是false，也就意味着被这两种引用类型引用的对象，如果没有其他额外处理，只要Reference对象还存活，那引用的对象是不会被回收的。Final references和对象是否重写了finalize方法有关，不在本文分析范围之内，我们接下来看看Phantom references。
PhantomReference
可以看到虚引用的get方法永远返回null，我们看个demo。
从以上代码中可以看到，虚引用能够在指向对象不可达时得到一个'通知'（其实所有继承References的类都有这个功能），需要注意的是GC完成后，phanRef.referent依然指向之前创建Object，也就是说Object对象一直没被回收！
而造成这一现象的原因在上一小节末尾已经说了：对于Final references和 Phantom references，clear_referent字段传入的时false，也就意味着被这两种引用类型引用的对象，如果没有其他额外处理，在GC中是不会被回收的。
对于虚引用来说，从refQueue.remove();得到引用对象后，可以调用clear方法强行解除引用和对象之间的关系，使得对象下次可以GC时可以被回收掉。
End
针对文章开头提出的几个问题，看完分析，我们已经能给出回答：
1. A menudo vemos en línea presentación de referencia es suave: será la recuperación de la memoria de las veces, que la memoria es insuficiente se define cómo? Por eso se llama fuera de la memoria?
referencias suaves se recuperan bajo de memoria, la memoria baja y la definición del objeto de referencia y la hora actual para obtener el tamaño de la memoria de almacenamiento dinámico disponible tiene una relación, la fórmula de cálculo también se ha dado anteriormente.
2. Para la presentación en línea de referencia virtual son: inexistentes, y varias otras referencias son diferentes, el ciclo de vida de referencia virtual y no determina objeto. Se utiliza principalmente para rastrear objetos recuperados actividad recolector de basura. ¿Es realmente?
En sentido estricto, la referencia fantasma afectará el ciclo de vida del objeto, si no hay tratamiento, siempre y cuando la referencia fantasma no se recupera, y que hace referencia a un objeto nunca se recuperará. Así que, en general, después de obtener el objeto PhantomReference de ReferenceQueue, si el objeto PhantomReference no se recupera, entonces (como la que se hace referencia por otros objetos alcanzables GC raíz), es necesario llamar a una forma clara de PhantomReference ascensor y su referencia a una relación de referencia de objeto.
3. referencia fantasma en las que se ha utilizado en la escena en Jdk?
DirectByteBuffer es una referencia fantasma subclase Cleaner.java de aplicar la recuperación memoria de pila externa, seguimiento va a escribir un artículo para el dicho montón de memoria fuera de los pros y los contras.
Artículo sensación bueno de hierro hasta el punto de atención de un hermano pequeño a él!