java内存管理分为内存分配和内存回收，都不需要程序员负责，垃圾回收的机制主要是看对象是否有引用指向该对象。
java对象的引用包括
强引用，软引用，弱引用，虚引用
Java中提供这四种引用类型主要有两个目的：
第一是可以让程序员通过代码的方式决定某些对象的生命周期；
第二是有利于JVM进行垃圾回收。
下面来阐述一下这四种类型引用的概念：
１．强引用
是指创建一个对象并把这个对象赋给一个引用变量。
比如：
Object object =new Object();
String str ="hello"; 强引用有引用变量指向时永远不会被垃圾回收，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。
public class Main {
public static void main(String[] args) {
new Main().fun1();
}
public void fun1() {
Object object = new Object();
Object[] objArr = new Object[1000];
}
}当运行至Object[] objArr = new Object[1000];这句时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是，当fun1运行完之后，object和objArr都已经不存在了，所以它们指向的对象都会被JVM回收。
如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。
比如Vector类的clear方法中就是通过将引用赋值为null来实现清理工作的：
public synchronized E remove(int index) {
modCount++;
if (index >= elementCount)
throw new ArrayIndexOutOfBoundsException(index);
Object oldValue = elementData[index];
int numMoved = elementCount - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--elementCount] = null; // Let gc do its work
return (E)oldValue;
} 2.软引用（SoftReference）
如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它；
如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。
软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露，增强程序的健壮性。
SoftReference的特点是它的一个实例保存对一个Java对象的软引用， 该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。
也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对 这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。
另外，一旦垃圾线程回收该Java对象之 后，get()方法将返回null。
举个栗子：
MyObject aRef = new MyObject();
SoftReference aSoftRef=new SoftReference(aRef); 此时，对于这个MyObject对象，有两个引用路径，一个是来自SoftReference对象的软引用，一个来自变量aRef 的强引用，所以这个MyObject对象是强可及对象。
aRef = null;
此后，这个MyObject对象成为了软引用对象。如果垃圾收集线程进行内存垃圾收集，并不会因为有一个SoftReference对该对象的引用而始终保留该对象。
Java虚拟机的垃圾收集线程对软可及对象和其他一般Java对象进行了区别对待:软可及对象的清理是由垃圾收集线程根据其特定算法按照内存需求决定的。
也就是说，垃圾收集线程会在虚拟机抛出OutOfMemoryError之前回收软可及对象，而且虚拟机会尽可能优先回收长时间闲置不用的软可及对象，对那些刚刚构建的或刚刚使用过的“新”软可反对象会被虚拟机尽可能保留。在回收这些对象之前，我们可以通过:
MyObject anotherRef=(MyObject)aSoftRef.get();
重新获得对该实例的强引用。而回收之后，调用get()方法就只能得到null了。
使用ReferenceQueue清除失去了软引用对象的SoftReference：
ReferenceQueue queue = new ReferenceQueue();
SoftReference ref = new SoftReference(aMyObject, queue); 那么当这个SoftReference所软引用的aMyOhject被垃圾收集器回收的同时，ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说，ReferenceQueue中保存的对象是Reference对象，而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出，它是一个队列，当我们调用它的poll()方法的时候，如果这个队列中不是空队列，那么将返回队列前面的那个Reference对象。
SoftReference ref = null;
while ((ref = (EmployeeRef) q.poll()) != null) {
// 清除ref
} 3.弱引用（WeakReference）
弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。每个对象实例有自己的生命周期，这里采用弱引用就可以在不影响对象实例生命周期的情况下对其引用
下面是使用示例：
public class test {
public static void main(String[] args) {
WeakReference<People> reference = new WeakReference<People>(new People("zhouqian",20));
System.out.println(reference.get());
System.gc();//通知GVM回收资源
System.out.println(reference.get());
}
}
class People{
public String name;
public int age;
public People(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "[name:"+name+",age:"+age+"]";
}
}
输出结果： [name:zhouqian,age:20]
null
第二个输出结果是null，这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联，如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。
比如：将代码做一点小更改：
package yinyong; import java.lang.ref.WeakReference;
public class test {
public static void main(String[] args) {
People people=new People("zhouqian",20);
//关联强引用 (people为root为强可及)
WeakReference<People>reference=new WeakReference<People>(people);
System.out.println(reference.get());
System.gc();
System.out.println(reference.get());
}
}
class People{
public String name;
public int age;
public People(String name,int age) {
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "[name:"+name+",age:"+age+"]";
}
}
//结果发生了很大的变化 [name:zhouqian,age:20] [name:zhouqian,age:20]
弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。
4.虚引用（PhantomReference）
虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期,get方法返回null,在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。
要注意的是，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。
public class PhantomReference<T> extends Reference<T> {
/**
* Returns this reference object's referent. Because the referent of a
* phantom reference is always inaccessible, this method always returns
* <code>null</code>.
*
* @return <code>null</code>
*/
public T get() {
return null;
}
public PhantomReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
public class Main {
public static void main(String[] args) {
ReferenceQueue<String> queue = new ReferenceQueue<String>();
PhantomReference<String> pr = new PhantomReference<String>(new String("hello"), queue);
System.out.println(pr.get());
}
}
输出结果： null
软引用和弱引用
对于强引用，我们平时在编写代码时经常会用到。而对于其他三种类型的引用，使用得最多的就是软引用和弱引用，这2种既有相似之处又有区别。它们都是用来描述非必需对象的，但是被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。
在SoftReference类中，有三个方法，两个构造方法和一个get方法（WekReference类似）：
两个构造方法：
public SoftReference(T referent) {
super(referent);
this.timestamp = clock;
}
public SoftReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
this.timestamp = clock;
} get方法用来获取与软引用关联的对象的引用，如果该对象被回收了，则返回null。
在使用软引用和弱引用的时候，我们可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。
引用队列
在上节的代码中，我们新建了一个引用队列（ReferenceQueue）对象，并且在创建软引用、弱引用和虚引用对象时将其作为参数传入对应引用的构造方法中。在文章的开头提到过可以利用引用队列来检测某个引用指向的对象是否被垃圾回收器回收，那么具体应该怎么做呢。我们可以看一下 3 类引用的源码，这里以弱引用为例（剩余两种可以类比）：
public class WeakReference<T> extends Reference<T> {
public WeakReference(T referent) {
super(referent);
}
public WeakReference(T referent, ReferenceQueue<? super T> q) {
super(referent, q);
}
}
可以看到 WeakReference 类继承了 Reference 类，可以猜到 Reference 类是 3 种引用的基类，我们看看这个类的源码 Reference.java：
public abstract class Reference<T> {
private T referent; /* Treated specially by GC */
volatile ReferenceQueue<? super T> queue;
/* When active: NULL
* pending: this
* Enqueued: next reference in queue (or this if last)
* Inactive: this
*/
@SuppressWarnings("rawtypes")
Reference next; // 引用所处的状态不同时，该属性保存了不同的信息
// ...
/**
* 获取当前引用所指向的对象的方法，如果所指向对象已经被 GC 回收，那么返回 null
*/
public T get() {
return this.referent;
}
/**
* 清除该引用所指向的对象，该方法会在 GC 回收该引用指向的对象后被 GC 调用，
* 之后，通过该引用对象的 get 方法得到的返回值为 null, 该方法不应该被程序员主动调用
*/
public void clear() {
this.referent = null;
}
/* -- Queue operations -- */
/**
* 判断当前引用是否已经进入对应的引用队列，
* 如果构造该引用对象时没有指定对应的引用队列，那么该方法始终返回 false
*/
public boolean isEnqueued() {
return (this.queue == ReferenceQueue.ENQUEUED);
}
/**
* 如果当前引用对象的引用队列属性（构造时由参数指定）不为 null,
* 那么当这个引用所指向的对象被 GC 回收之后会由 GC 调用这个方法，
* 代表将该引用进入对应的引用队列（即该引用指向的对象被回收）
*/
public boolean enqueue() {
return this.queue.enqueue(this);
}
/* -- Constructors -- */
Reference(T referent) {
this(referent, null);
}
Reference(T referent, ReferenceQueue<? super T> queue) {
this.referent = referent;
this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
}
}
我们在 Reference 类中的 enqueue 方法（这个方法本身会被 GC 线程调用）中发现其直接调用了对应引用队列（ReferenceQueue）的 enqueue 方法，我们来看看 ReferenceQueue 类的这个方法：
public class ReferenceQueue<T> {
/**
* Constructs a new reference-object queue.
*/
public ReferenceQueue() { }
// ...
static private class Lock { };
private Lock lock = new Lock();
private volatile Reference<? extends T> head = null;
private long queueLength = 0;
// 引用对象本身入队列的过程就是一个向单向链表中插入节点的过程
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;
if ((queue == NULL) || (queue == ENQUEUED)) {
return false;
}
assert queue == this;
r.queue = ENQUEUED; // 更新引用入队状态
// 前插法插入链表节点
r.next = (head == null) ? r : head;
head = r;
queueLength++;
if (r instanceof FinalReference) {
sun.misc.VM.addFinalRefCount(1);
}
lock.notifyAll();
return true;
}
}
/**
* 返回当前引用队列中的第一个引用对象，如果不存在则返回 null
* 该方法不会阻塞线程
*/
public Reference<? extends T> poll() {
if (head == null)
return null;
synchronized (lock) {
return reallyPoll();
}
}
/**
* 返回当前引用队列中第一个可用的引用对象，如果没有，则阻塞线程一定时间（参数指定）
* 阻塞时间过后，如果当前队列中仍然没有可用的引用对象，那么抛出中断异常（InterruptedException）
*/
public Reference<? extends T> remove(long timeout)
throws IllegalArgumentException, InterruptedException
{
if (timeout < 0) {
throw new IllegalArgumentException("Negative timeout value");
}
synchronized (lock) {
Reference<? extends T> r = reallyPoll();
if (r != null) return r;
long start = (timeout == 0) ? 0 : System.nanoTime();
for (;;) {
lock.wait(timeout);
r = reallyPoll();
if (r != null) return r;
if (timeout != 0) {
long end = System.nanoTime();
timeout -= (end - start) / 1000_000;
if (timeout <= 0) return null;
start = end;
}
}
}
}
/**
* 阻塞调用线程，直到当前引用队列中存在可用的引用对象，将该引用对象从引用队列中移除并返回该引用对象
*/
public Reference<? extends T> remove() throws InterruptedException {
return remove(0);
}
}
利用注释和源代码，我们就可以将整个过程的逻辑串起来了：
GC 线程回收对象 -> 将相关指向这个对象的引用加入到其引用队列（如果有）-> 更新引用入队状态（isEnqueued 方法返回 true）-> 在 Java 代码中可以得到引用队列中的已经入队的引用（即得到要回收对象的对应引用对象，作为对象回收的一个通知）。
下面看一个小例子，利用引用队列来得知回收的对象，我们在上一节的代码中新建一个静态内部类 ReferenceQueueTest
// 引用队列测试类
static class ReferenceQueueTest {
ReferenceQueue<byte[]> referenceQueue = new ReferenceQueue<>();
// 对象回收时的引用通知测试
void testReferenceNotify() {
WeakReference<byte[]> weakReference = new WeakReference<>(new byte[1024], referenceQueue);
// 后面的 ReferenceQueue.remove 方法会阻塞调用线程，因此开子线程进行操作
Thread thread = new Thread(() -> {
try {
for (Reference pr; (pr = referenceQueue.remove()) != null; ) {
System.out.println(pr + " 引用所指向的对象被回收!");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
});
/*
因为 ReferenceQueue 对象的 remove 方法是阻塞线程的，因此子线程需设置守护线程，
否则如果 ReferenceQueue 中没有可取出的引用对象会导致线程一直阻塞，程序不能退出
*/
thread.setDaemon(true);
thread.start();
// 启动垃圾回收动作，将弱引用指向的对象回收
System.gc();
}
}
在 main 方法中新建该内部类对象并且调用 testReferenceNotify 方法：
可以看到，当弱引用指向的对象被回收之后，我们成功的从该弱引用对象中的引用对象中得到了该弱引用对象，即完成了对象回收的监视过程。
对象可及性的判断
在很多时候，一个对象并不是从根集直接引用的，而是一个对象被其他对象引用，甚至同时被几个对象所引用，从而构成一个以根集为顶的树形结构。如图2所示
如何利用软引用和弱引用解决OOM问题
前面讲了关于软引用和弱引用相关的基础知识，那么到底如何利用它们来优化程序性能，从而避免OOM的问题呢？
下面举个例子，假如有一个应用需要读取大量的本地图片，如果每次读取图片都从硬盘读取，则会严重影响性能，但是如果全部加载到内存当中，又有可能造成内存溢出，此时使用软引用可以解决这个问题。
设计思路是：用一个HashMap来保存图片的路径 和 相应图片对象关联的软引用之间的映射关系，在内存不足时，JVM会自动回收这些缓存图片对象所占用的空间，从而有效地避免了OOM的问题。在Android开发中对于大量图片下载会经常用到。
3．使用软引用构建敏感数据的缓存
3.4通过软可及对象重获方法实现Java对象的高速缓存
publicclass Employee {
private String id; // 雇员的标识号码
private String name; // 雇员姓名
private String department; // 该雇员所在部门
private String Phone; // 该雇员联系电话
privateintsalary; // 该雇员薪资
private String origin; // 该雇员信息的来源
// 构造方法
public Employee(String id) {
this.id = id;
getDataFromlnfoCenter();
}
// 到数据库中取得雇员信息
private void getDataFromlnfoCenter() {
// 和数据库建立连接井查询该雇员的信息，将查询结果赋值
// 给name，department，plone，salary等变量
// 同时将origin赋值为"From DataBase"
}
}这个Employee类的构造方法中我们可以预见，如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这是需要消耗很多时间的。下面是一个对Employee对象进行缓存的缓存器的定义:
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.Hashtable;
public class EmployeeCache {
static private EmployeeCache cache;// 一个Cache实例
private Hashtable<String,EmployeeRef> employeeRefs;// 用于Chche内容的存储
private ReferenceQueue<Employee> q;// 垃圾Reference的队列
// 继承SoftReference，使得每一个实例都具有可识别的标识。
// 并且该标识与其在HashMap内的key相同。
privateclass 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<String,EmployeeRef>();
q = new ReferenceQueue<Employee>();
}
// 取得缓存器实例
publicstatic EmployeeCache getInstance() {
if (cache == null) {
cache = new EmployeeCache();
}
return cache;
}
// 以软引用的方式对一个Employee对象的实例进行引用并保存该引用
privatevoid cacheEmployee(Employee em) {
cleanCache();// 清除垃圾引用
EmployeeRef ref = new EmployeeRef(em, q);
employeeRefs.put(em.getID(), ref);
}
// 依据所指定的ID号，重新获取相应Employee对象的实例
public Employee getEmployee(String ID) {
Employee em = null;
// 缓存中是否有该Employee实例的软引用，如果有，从软引用中取得。
if (employeeRefs.containsKey(ID)) {
EmployeeRef ref = (EmployeeRef) employeeRefs.get(ID);
em = (Employee) ref.get();
}
// 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，
// 并保存对这个新建实例的软引用
if (em == null) {
em = new Employee(ID);
System.out.println("Retrieve From EmployeeInfoCenter. ID=" + ID);
this.cacheEmployee(em);
}
return em;
}
// 清除那些所软引用的Employee对象已经被回收的EmployeeRef对象
private void cleanCache() {
EmployeeRef ref = null;
while ((ref = (EmployeeRef) q.poll()) != null) {
employeeRefs.remove(ref._key);
}
}
// 清除Cache内的全部内容
public void clearCache() {
cleanCache();
employeeRefs.clear();
System.gc();
System.runFinalization();
}
}
4．使用弱引用构建非敏感数据的缓存
public class SocketManager {
private Map<Socket, User> m = new HashMap<Socket, User>();
publicvoid setUser(Socket s, User u) {
m.put(s, u);
}
public User getUser(Socket s) {
returnm.get(s);
}
publicvoid removeUser(Socket s) {
m.remove(s);
}
}import java.util.WeakHashMap;
class Element {
private String ident;
public Element(String id) {
ident = id;
}
public String toString() {
returnident;
}
public int hashCode() {
returnident.hashCode();
}
public boolean equals(Object obj) {
return obj instanceof Element && ident.equals(((Element) obj).ident);
}
protected void finalize(){
System.out.println("Finalizing "+getClass().getSimpleName()+" "+ident);
}
}
class Key extends Element{
public Key(String id){
super(id);
}
}
class Value extends Element{
public Value (String id){
super(id);
}
}
public class CanonicalMapping {
public static void main(String[] args){
int size=1000;
Key[] keys=new Key[size];
WeakHashMap<Key,Value> map=new WeakHashMap<Key,Value>();
for(int i=0;i<size;i++){
Key k=new Key(Integer.toString(i));
Value v=new Value(Integer.toString(i));
if(i%3==0)
keys[i]=k;
map.put(k, v);
}
System.gc();
}
}从打印结果可以看出，当执行System.gc()方法后，垃圾回收器只会回收那些仅仅持有弱引用的Key对象。id可以被3整除的Key对象持有强引用，因此不会被回收。
publicclass SocketManager {
private Map<Socket,User> m = new WeakHashMap<Socket,User>();
publicvoid setUser(Socket s, User u) {
m.put(s, u);
}
public User getUser(Socket s) {
returnm.get(s);
}
}