Java_四种引用

     Java有四种引用类型，strongreference，softreference，weakreference，phantomreference。这四种引用的强度按照上面的顺序依次减弱，下面通过几个例子简单了解一下这四种引用类型。

        StrongReference

        这个不用多讲了，这是java默认的引用类型，如果不特意使用java.lang.ref下的类，那么程序中的所有引用都是强引用。 有强引用存在的对象永远都不会被gc收集，所以在内存不够用时，JVM宁愿抛出OutOfMemoryError这样的错误，也不愿意将强引用对象进行回收。

        SoftReference

        软引用不会保证对象一定不会被回收，只能最大可能保证。 如果内存有剩余，那么软引用对象不会被回收，如果内存不足，那么gc会回收软引用对象。 所以这种特性可以用来实现缓存技术。软引用要用java.lang.ref.SoftReference来实现。

Java代码  

1. public class SoftTest{  
2.     public static void main(String[] args) {  
3.         Object ref = new Object();//ref是Object对象的强引用  
4.   
5.         //将一个软引用指向对象，此时Object对象有两个引用  
6.         SoftReference<Object> sf = new SoftReference<Object>(ref);  
7.   
8.         ref = null;//去除对象的强引用  
9.         System.gc();//gc只有在内存不足是才会回收软引用对象  
10.     }  
11. }  

public class SoftTest{
	public static void main(String[] args) {
		Object ref = new Object();//ref是Object对象的强引用

		//将一个软引用指向对象，此时Object对象有两个引用
		SoftReference<Object> sf = new SoftReference<Object>(ref);

		ref = null;//去除对象的强引用
		System.gc();//gc只有在内存不足是才会回收软引用对象
	}
}

        WeakReference

        除了通过java.lang.ref.WeakReference来使用弱引用，WeakHashMap同样也利用了弱引用。
        和软引用不同的是， 弱引用一定会被gc回收，不管内存是否不足。

Java代码  

1. public class WeakTest{  
2.     public static void main(String[] args) {  
3.         Object ref = new Object();//ref是Object对象的强引用  
4.   
5.         //将一个弱引用指向对象，此时Object对象有两个引用  
6.         WeakReference<Object> wf = new WeakReference<Object>(ref);  
7.   
8.         ref = null;//去除对象的强引用  
9.         System.gc();//gc对弱引用对象进行回收  
10.     }  
11. }  

public class WeakTest{
	public static void main(String[] args) {
		Object ref = new Object();//ref是Object对象的强引用

		//将一个弱引用指向对象，此时Object对象有两个引用
		WeakReference<Object> wf = new WeakReference<Object>(ref);

		ref = null;//去除对象的强引用
		System.gc();//gc对弱引用对象进行回收
	}
}

        PhantomReference

        幽灵引用，也叫虚引用。java.lang.ref.PhantomReference类中只有一个方法get()，而且几乎没有实现，只是返回null。而且这个类只有一个构造器(软引用和弱引用均有两个构造器)：

Java代码  

1. public PhantomReference(T referent, ReferenceQueue<? super T> q) {  
2.     super(referent, q);  
3.     }  

public PhantomReference(T referent, ReferenceQueue<? super T> q) {
	super(referent, q);
    }

        也就是说，幽灵引用只能与ReferenceQueue（后面会提到这个类）一起使用。如果一个对象仅有幽灵引用，那么它就像没有任何引用一样， 在任何时候都可能被gc回收。幽灵引用主要用来跟踪对象被垃圾回收的活动。

Java代码  

1. public class PhantomTest{  
2.     public static void main(String[] args) {  
3.         Object ref = new Object();//ref是Object对象的强引用  
4.   
5.         //将一个幽灵引用指向对象，PhantomReference必须与ReferenceQueue一同使用  
6.         PhantomReference<Object> pf = new PhantomReference<Object>(ref, new ReferenceQueue<Object>());  
7.   
8.         System.out.println(pf.get());  
9.     }  
10. }  

public class PhantomTest{
	public static void main(String[] args) {
		Object ref = new Object();//ref是Object对象的强引用

		//将一个幽灵引用指向对象，PhantomReference必须与ReferenceQueue一同使用
		PhantomReference<Object> pf = new PhantomReference<Object>(ref, new ReferenceQueue<Object>());

		System.out.println(pf.get());
	}
}

        ReferenceQueue

        如果一个对象只有软引用、弱引用或者幽灵引用，gc在回收对象时，JVM会自动将其引用放入一个ReferenceQueue中。WeakHashMap就是利用了ReferenceQueue来实现清除没有强引用Entry的。将上面的弱引用例子稍微改一下：

Java代码  

1. public class ReferenceQueueTest{  
2.     public static void main(String[] args) {  
3.         Object ref = new Object();//ref是Object对象的强引用  
4.         System.out.println(ref);  
5.           
6.         ReferenceQueue<Object> rq=new ReferenceQueue<Object>();//有强引用的ReferenceQueue  
7.   
8.         WeakReference<Object> sf = new WeakReference<Object>(ref,rq);//构造弱引用时传入ReferenceQueue  
9.         System.out.println(sf);  
10.   
11.         ref = null;//去除对象的强引用，在这里加个断点，进行调试  
12.         System.gc();//gc对弱引用对象进行回收  
13.         System.out.println(rq.poll());  
14.     }  
15. }  

public class ReferenceQueueTest{
	public static void main(String[] args) {
		Object ref = new Object();//ref是Object对象的强引用
		System.out.println(ref);
		
		ReferenceQueue<Object> rq=new ReferenceQueue<Object>();//有强引用的ReferenceQueue

		WeakReference<Object> sf = new WeakReference<Object>(ref,rq);//构造弱引用时传入ReferenceQueue
		System.out.println(sf);

		ref = null;//去除对象的强引用，在这里加个断点，进行调试
		System.gc();//gc对弱引用对象进行回收
		System.out.println(rq.poll());
	}
}

        注意，运行这个程序需要用debug模式进行调试，在上面说明的地方加个断点。如果直接运行，结果很可能只是个null，用debug调试的话会看到输出的是弱引用的地址。程序输出的sf结果和rq.poll()结果相同。