这篇文章非常棒：http://alinazh.blog.51cto.com/5459270/1276173

Java中四种引用：强、软、弱、虚引用

1.1、强引用
当我们使用new 这个关键字创建对象时，被创建的对象就是强引用，如Object object = new Object() 这个Object()就是一个强引用。如果一个对象具有强引用，垃圾回收器就不会去回收有强引用的对象，如当jvm内存不足时，具备强引用的对象，虚拟机宁可会报内存空间不足的异常来终止程序，也不会靠垃圾回收器去回收该对象来解决内存。

1.2、软引用

如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；

如果内存空间不足了，就会回收这些对象的内存。

只要垃圾回收器没有回收它，该对象就可以被程序使用。

软引用可用来实现内存敏感的高速缓存（下文给出示例）。

软引用可以和一个引用队列（ReferenceQueue）关联使用：

String str = new String("test");
ReferenceQueue<String> rq = new ReferenceQueue<>();
SoftReference sf = new SoftReference(str,rq);

        如果软引用(sf)所引用的对象(str)被垃圾回收器回收，Java虚拟机就会把这个软引用(sf)加入到与之关联的引用队列(rq)中,之后可以通过循环调用rq的poll()方法，来清除无用的软引用对象(sf)

        如果软引用所引用的对象(str)还没有被垃圾回收器回收，则可以通过这个引用(sf)的get()方法重新获得对引用对象(str)的强引用.

 

1.3、弱引用
如果一个对象只具有弱引用，只要垃圾回收器在自己的内存空间中线程检测到了，就会立即被回收，对应内存也会被释放掉。相比软引用弱引用的生命周期要比软引用短很多。不过，如果垃圾回收器是一个优先级很低的线程，也不一定会很快就会释放掉软引用的内存。

通俗的来说就是：发生GC时必定回收弱引用指向的内存空间。

 

示例代码：

public static void main(String[] args) {
	String string = new String("test");
	ReferenceQueue<String> rq = new ReferenceQueue<>();
	WeakReference<String> wr = new WeakReference<String>(string,rq);
	System.out.println(wr.get());
	string = null;
	System.gc();
	System.out.println(wr.get());
}

运行结果：

test
null

 

1.4、虚引用

又称为幽灵引用或幻影引用，虚引用既不会影响对象的生命周期，也无法通过虚引用来获取对象实例，仅用于在发生GC时接收一个系统通知。

相关问题一、若一个对象的引用类型有多个，那到底如何判断它的可达性呢？其实规则如下：

　　1. 单条引用链的可达性以最弱的一个引用类型来决定；
　　2. 多条引用链的可达性以最强的一个引用类型来决定；

      

     我们假设图2中引用①和③为强引用，⑤为软引用，⑦为弱引用，对于对象5按照这两个判断原则，路径①-⑤取最弱的引用⑤，因此该路径对对象5的引用为软引用。同样，③-⑦为弱引用。在这两条路径之间取最强的引用，于是对象5是一个软可及对象（当将要发生OOM时则会被回收掉）。

 

相关问题二、与引用相关联的引用队列的作用是什么

引用队列的作用：使用ReferenceQueue清除失去了引用对象的Reference（SoftReference，WeakReference等）
作为一个Java对象，SoftReference对象除了具有保存软引用的特殊性之外，也具有Java对象的一般性。所以，当软可及对象被回收之后，虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值，需要一个适当的清除机制，避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候，使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法，如:
ReferenceQueue queue = new ReferenceQueue();
SoftReference ref=new SoftReference(aMyObject, queue);
那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说，ReferenceQueue中保存的对象是Reference对象，而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出，它是一个队列，当我们调用它的poll()方法的时候，如果这个队列中不是空队列，那么将返回队列前面的那个Reference对象。
在任何时候，我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空，将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法，我们可以检查哪个SoftReference所软引用的对象已经被回收。于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉。常用的方式为:
SoftReference ref = null;
while ((ref = (EmployeeRef) q.poll()) != null) {
// 清除ref
}
理解了ReferenceQueue的工作机制之后，我们就可以开始构造一个Java对象的高速缓存器了。下面是一个高速缓存器的代码：
EmployeeCache 类：
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.Hashtable;

public class EmployeeCache {
	static private EmployeeCache cache;
	private Hashtable<String, EmployeeRef> employeeRefs;
	private ReferenceQueue<Employee> q;
	private class EmployeeRef extends SoftReference<Employee>{
		private String _key="";
		public EmployeeRef(Employee em,ReferenceQueue<Employee> q) {
			super(em,q);
			_key=em.getId();
		}
	}
	private EmployeeCache() {
		employeeRefs = new Hashtable<>();
		q = new ReferenceQueue<>();
	}
	
	public static EmployeeCache getInstance(){
		if(cache==null){
			cache = new EmployeeCache();
		}
		return cache;
	}
	
	private void cacheEmployee(Employee em){
		cleanCache();
		EmployeeRef ref = new EmployeeRef(em, q);
		employeeRefs.put(em.getId(), ref);	
	}
	
	public Employee getEmployee(String id){
		Employee employee = null;
		if(employeeRefs.contains(id)){
			EmployeeRef ref = employeeRefs.get(id);
			employee = ref.get();
		}
		
		if(employee == null){
			employee = new Employee(id);
			System.out.println("从信息中心获取新的对象");
			this.cacheEmployee(employee);
		}
		return employee;
	}
	private void cleanCache() {
		EmployeeRef ref = null;
		while((ref=(EmployeeRef) q.poll())!=null){
			employeeRefs.remove(ref._key);
		}
	}
	public void clearCache(){
		cleanCache();
		employeeRefs.clear();
		System.gc();
		System.runFinalization();
	}
}

Employee类：

import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;

public class Employee {
	private String id;
	private String name;
	private String department;
	private String phone;
	private int salary;
	private String origin;

	public Employee(String id) {
		this.id = id;
		getDataFromInfoCenter();
	}

	private void getDataFromInfoCenter() {

	}

	public String getId() {
		String id = (int) (Math.random() * 10 + 1) + "";
		return id;
	}
}
 

2、jdk中的引用实现类

代表软引用的类：java.lang.ref.SoftReference
代表弱引用的类：java.lang.ref.WeakReference
代表虚引用的类：java.lang.ref.PhantomReference
他们同时继承了：java.lang.ref.Reference
引用队列：java.lang.ref.ReferenceQueue,这个引用队列是可以三种引用类型联合使用的，以便跟踪java虚拟机回收所引用对象的活动。

 

 

附：相关源码

  1 /*
  2  * @(#)ReferenceQueue.java    1.23 03/12/19
  3  *
  4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
  5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
  6  */
  7 
  8 package java.lang.ref;
  9 
 10 /**
 11  * Reference queues, to which registered reference objects are appended by the
 12  * garbage collector after the appropriate reachability changes are detected.
 13  *
 14  * @version  1.23, 12/19/03
 15  * @author   Mark Reinhold
 16  * @since    1.2
 17  */
 18 
 19 public class ReferenceQueue<T> {
 20 
 21     /**
 22      * Constructs a new reference-object queue.
 23      */
 24     public ReferenceQueue() { }
 25 
 26     private static class Null extends ReferenceQueue {
 27     boolean enqueue(Reference r) {
 28         return false;
 29     }
 30     }
 31 
 32     static ReferenceQueue NULL = new Null();
 33     static ReferenceQueue ENQUEUED = new Null();
 34 
 35     static private class Lock { };
 36     private Lock lock = new Lock();
 37     private Reference<? extends T> head = null;
 38     private long queueLength = 0;
 39 
 40     boolean enqueue(Reference<? extends T> r) {    /* Called only by Reference class */
 41     synchronized (r) {
 42         if (r.queue == ENQUEUED) return false;
 43         synchronized (lock) {
 44         r.queue = ENQUEUED;
 45         r.next = (head == null) ? r : head;
 46         head = r;
 47         queueLength++;
 48                 if (r instanceof FinalReference) {
 49                     sun.misc.VM.addFinalRefCount(1);
 50                 }
 51         lock.notifyAll();
 52         return true;
 53         }
 54     }
 55     }
 56 
 57     private Reference<? extends T> reallyPoll() {    /* Must hold lock */
 58     if (head != null) {
 59         Reference<? extends T> r = head;
 60         head = (r.next == r) ? null : r.next;
 61         r.queue = NULL;
 62         r.next = r;
 63         queueLength--;
 64             if (r instanceof FinalReference) {
 65                 sun.misc.VM.addFinalRefCount(-1);
 66             }
 67         return r;
 68     }
 69     return null;
 70     }
 71 
 72     /**
 73      * Polls this queue to see if a reference object is available.  If one is
 74      * available without further delay then it is removed from the queue and
 75      * returned.  Otherwise this method immediately returns <tt>null</tt>.
 76      *
 77      * @return  A reference object, if one was immediately available,
 78      *          otherwise <code>null</code>
 79      */
 80     public Reference<? extends T> poll() {
 81     synchronized (lock) {
 82         return reallyPoll();
 83     }
 84     }
 85 
 86     /**
 87      * Removes the next reference object in this queue, blocking until either
 88      * one becomes available or the given timeout period expires.
 89      *
 90      * <p> This method does not offer real-time guarantees: It schedules the
 91      * timeout as if by invoking the {@link Object#wait(long)} method.
 92      *
 93      * @param  timeout  If positive, block for up <code>timeout</code>
 94      *                  milliseconds while waiting for a reference to be
 95      *                  added to this queue.  If zero, block indefinitely.
 96      *
 97      * @return  A reference object, if one was available within the specified
 98      *          timeout period, otherwise <code>null</code>
 99      *
100      * @throws  IllegalArgumentException
101      *          If the value of the timeout argument is negative
102      *
103      * @throws  InterruptedException
104      *          If the timeout wait is interrupted
105      */
106     public Reference<? extends T> remove(long timeout)
107     throws IllegalArgumentException, InterruptedException
108     {
109     if (timeout < 0) {
110         throw new IllegalArgumentException("Negative timeout value");
111     }
112     synchronized (lock) {
113         Reference<? extends T> r = reallyPoll();
114         if (r != null) return r;
115         for (;;) {
116         lock.wait(timeout);
117         r = reallyPoll();
118         if (r != null) return r;
119         if (timeout != 0) return null;
120         }
121     }
122     }
123 
124     /**
125      * Removes the next reference object in this queue, blocking until one
126      * becomes available.
127      *
128      * @return A reference object, blocking until one becomes available
129      * @throws  InterruptedException  If the wait is interrupted
130      */
131     public Reference<? extends T> remove() throws InterruptedException {
132     return remove(0);
133     }
134 
135 }
ReferenceQueue
 1 /*
 2  * @(#)SoftReference.java    1.34 03/12/19
 3  *
 4  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 5  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 6  */
 7 
 8 package java.lang.ref;
 9 
10 
11 /**
12  * Soft reference objects, which are cleared at the discretion of the garbage
13  * collector in response to memory demand.  Soft references are most often used
14  * to implement memory-sensitive caches.
15  *
16  * <p> Suppose that the garbage collector determines at a certain point in time
17  * that an object is <a href="package-summary.html#reachability">softly
18  * reachable</a>.  At that time it may choose to clear atomically all soft
19  * references to that object and all soft references to any other
20  * softly-reachable objects from which that object is reachable through a chain
21  * of strong references.  At the same time or at some later time it will
22  * enqueue those newly-cleared soft references that are registered with
23  * reference queues.
24  *
25  * <p> All soft references to softly-reachable objects are guaranteed to have
26  * been cleared before the virtual machine throws an
27  * <code>OutOfMemoryError</code>.  Otherwise no constraints are placed upon the
28  * time at which a soft reference will be cleared or the order in which a set
29  * of such references to different objects will be cleared.  Virtual machine
30  * implementations are, however, encouraged to bias against clearing
31  * recently-created or recently-used soft references.
32  *
33  * <p> Direct instances of this class may be used to implement simple caches;
34  * this class or derived subclasses may also be used in larger data structures
35  * to implement more sophisticated caches.  As long as the referent of a soft
36  * reference is strongly reachable, that is, is actually in use, the soft
37  * reference will not be cleared.  Thus a sophisticated cache can, for example,
38  * prevent its most recently used entries from being discarded by keeping
39  * strong referents to those entries, leaving the remaining entries to be
40  * discarded at the discretion of the garbage collector.
41  *
42  * @version  1.34, 12/19/03
43  * @author   Mark Reinhold
44  * @since    1.2
45  */
46 
47 public class SoftReference<T> extends Reference<T> {
48 
49     /* Timestamp clock, updated by the garbage collector
50      */
51     static private long clock;
52 
53     /* Timestamp updated by each invocation of the get method.  The VM may use
54      * this field when selecting soft references to be cleared, but it is not
55      * required to do so.
56      */
57     private long timestamp;
58 
59     /**
60      * Creates a new soft reference that refers to the given object.  The new
61      * reference is not registered with any queue.
62      *
63      * @param referent object the new soft reference will refer to
64      */
65     public SoftReference(T referent) {
66     super(referent);
67     this.timestamp = clock;
68     }
69 
70     /**
71      * Creates a new soft reference that refers to the given object and is
72      * registered with the given queue.
73      *
74      * @param referent object the new soft reference will refer to
75      * @param q the queue with which the reference is to be registered,
76      *          or <tt>null</tt> if registration is not required
77      *
78      */
79     public SoftReference(T referent, ReferenceQueue<? super T> q) {
80     super(referent, q);
81     this.timestamp = clock;
82     }
83 
84     /**
85      * Returns this reference object's referent.  If this reference object has
86      * been cleared, either by the program or by the garbage collector, then
87      * this method returns <code>null</code>.
88      *
89      * @return   The object to which this reference refers, or
90      *           <code>null</code> if this reference object has been cleared
91      */
92     public T get() {
93     T o = super.get();
94     if (o != null) this.timestamp = clock;
95     return o;
96     }
97 
98 }
SoftReference