java对象四大引用案例


/**
 * 
 * @author zhaoYQ
 * 
 *
 */
public class Test1 {
	@Test
	public void strongReference() throws InterruptedException {
		 Test1 myObject = new Test1();
	     System.out.println("Gc前：" + myObject);
	 
	     System.gc();
	         TimeUnit.SECONDS.sleep(1);
	     //强引用:  未置空无法被GC
	     System.out.println("未置空Gc后打印：" + myObject);
	 
	     myObject = null; //置空可被GC
	     System.gc();
	     System.runFinalization();//强制调用finalize
	     TimeUnit.SECONDS.sleep(1);
	     System.out.println("置空后Gc后打印：" + myObject);//置空可被GC
 
	}
 
	
	protected void finalize() throws Throwable {
		System.out.println("对象被回收");
		super.finalize();
	}
 
}

2.软引用：


package com;
 
import java.lang.ref.SoftReference;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
/**
 * 
 * @author zhaoYQ
 *  软引用
 *
 */
public class Test1 {
	@Test
	public void strongReference() throws InterruptedException {
		 byte[] t1 = new byte[1024*1024*10];//10M
		 SoftReference<byte[]> softReference = new SoftReference<byte[]>(t1);
	     System.out.println("Gc前，打印对象：" + softReference.get());
	 
	     
	     t1=null;
	     System.gc();//将t1的引用置空//只存在软引用(不存在强引用)
	     TimeUnit.SECONDS.sleep(1);
	     System.out.println("Gc后，打印对象：" + softReference.get());
	     
	     //再次创建一个数组，堆中存不下的时候，垃圾回收器工作
	     //先回收一次，如果第一次回收后内存还是不够
	     //则再清理第二次，这一次会把软引用对象清除
	     byte[] t2 = new byte[1024*1024*15];//15M
	     System.gc();//启动GC(但是GC不一定会回收某个对象<要看当时堆内存环境>)
	     TimeUnit.SECONDS.sleep(1);
	     System.out.println("Gc后，打印对象：" + softReference.get());
	}
 
 
}

运行时设置堆内存大小(设置运行参数)：

-Xmx100M 当堆最大内存设置为100M时因为内存够用，所以出发GC时，对象不会被回收。

如下，当当堆最大内存设置为25M时因为内存不够用，所以当需要往堆中再次分配一个更大的t2时，就要回收t1了(所以软引用是当内存不够时才可能回收<内存空间够用时不会回收>)

3.弱引用：


package com;
 
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
/*
 System.gc();    等效于： Runtime.getRuntime().gc()
//告诉垃圾收集器打算进行垃圾收集，而垃圾收集器进不进行收集是不确定的
System.runFinalization();  等效于：    Runtime.getRuntime().runFinalization()
//强制调用已经失去引用的对象的finalize方法 
 */
/**
 * 
 * @author zhaoYQ
 * 
 *
 */
public class Test1 {
	@Test
	public void strongReference() throws InterruptedException {
		// 1.创建一个对象
		Test1 t1 = new Test1();// 强引用，未置空无法被GC
		// 2.创建一个弱引用，让弱引用引用对象t1
		WeakReference wr = new WeakReference(t1);
		// 3.切断t1和对象之间的引用
		t1 = null;
		// 4.取出弱引用所指代的对象
		System.out.println("gc前打印对象："+wr.get());//打印对象
 
		// 5.催促垃圾回收
		System.gc();
		TimeUnit.SECONDS.sleep(2);
		System.runFinalization();//强制调用finalize
 
		// 6.再次取出弱引用所指向的对象
		System.out.println("gc后打印对象："+wr.get());//null
 
	}
 
	
	protected void finalize() throws Throwable {
		System.out.println("对象被回收");
		super.finalize();
	}
 
}

执行结果如下：

gc前打印对象：com.Test1@fbb2c1

对象被回收

gc后打印对象：null

弱引用说明案例2：


package com.zyq.csmall.business.config;
import java.lang.ref.WeakReference;
import java.util.concurrent.TimeUnit;
public class Test {
    // 运行结果：
    //  weakRef = com.zyq.csmall.business.config.Test$1M@19f7e29
    //  M对象被回收
    //  weakRef = null
    public static void main(String[] args) throws InterruptedException {
            class M{
                protected void finalize() throws Throwable {
                    System.out.println("M对象被回收");
                }
            }
            WeakReference weakRef=new WeakReference(new M());
            System.out.println("weakRef = " + weakRef.get());
            System.gc();
            TimeUnit.SECONDS.sleep(1);
            System.out.println("weakRef = " + weakRef.get());
    }
}

4.虚引用：

使用的情景非常少，不用掌握。

虚引用需要用到PhantomReference类，用来在对象被回收时接收一个系统通知。

如果一个对象具有虚引用，那么它和没有任何引用一样，

被虚引用关联的对象引用通过get方法获取到的永远为null，

也就是说这种对象在任何时候都有可能被垃圾回收器回收，

通过这种方式关联的对象也无法调用对象中的方法。

虚引用主要是用来管理堆外内存的，通过ReferenceQueue这个类实现，当一个对象被回收的时候，会向这个引用队列里面添加相关数据，给一个通知。

设置虚引用的唯一目的，就是在这个对象被回收器回收的时候收到一个系统通知或者后续添加进一步的处理。

下边的情况下：当堆中的对象被回收时，用来通知垃圾回收器将堆外的这个对象同时回收掉。

虚引用这这种情景下：就可以在堆中的对象被回收时通知垃圾回收器去回收堆外的这个字节缓冲数组 (因为堆中使用字节缓冲数组的对象已经要被回收了，堆外的这个字节缓冲数组就没有存在的必要了)

案例：作者用意没看出来


package com;
 
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;
import java.nio.ByteBuffer;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
 
public class Test {//这个给List中不停存入数组的情况体现不出虚引用，这个案例作者的用意没体会出来
	//-verbose:gc -XX:+PrintGCDetails -XX:+DisableExplicitGC  -XX:MaxDirectMemorySize=40M
	//                                     禁止手动调用System.GC()   堆外最大内存是40M
	
	private static final List