java的四种引用

1. java 中的引用分为 4种

1.强引用 引用存在就不会被GC *

2.软引用 heap memory（堆内存）满了就会被GC掉 *

3.弱引用 每次GC就会回收掉（应用有：ThreadLocal） *

4.虚引用 每次GC就会回收掉（应用有，控制jvm外的内存） */

2. demo1 强引用案例1

public class ReferenceDemo {
    @Override
    protected void finalize()  throws Throwable{
        System.out.println( "ReferenceDemod对象死亡了");
    }
}

/**
 * 1.强应用就是我们平常的引用
 * 引用存在就不会被回收  引用！=null
 */
public  static   void   strongReference(){
    ReferenceDemo referenceDemo = new ReferenceDemo();
    System.out.println("1.引用是否存在"+referenceDemo);
    sleepThread(1000);
    System.gc();
    System.out.println("2.引用是否存在"+referenceDemo);
    sleepThread(1000);
    referenceDemo=null;
    System.gc();
    System.out.println("3.引用是否存在"+referenceDemo);

}

执行结果是：

1.引用是否存在com.gyj.study.referece.ReferenceDemo@1b6d3586

2.引用是否存在com.gyj.study.referece.ReferenceDemo@1b6d3586

3.引用是否存在null

ReferenceDemod对象死亡了

2、软引用 SoftRefernce 当heap memory 满了就会被GC回收掉；

/**
 * 2.软引用：heap momory 堆内存满了就会被GC回收掉；
 */
public static void softReference(){
    // 设置 jvm的内存为20m
    SoftReference<byte[]> sr= new SoftReference<byte[]>(new byte[1024 * 1024*10]);
    // 软引用对象 st---强引用--> 软引用实例---- 软引用----> 学习引用对象    学习对象比软引用 引用着，heap momory满了GC就会回收掉 学习引用对象（销毁）
    System.out.println("1 软引用类 引用 st ："+sr);

    System.out.println("1 byte[]引用类 引用  ："+sr.get());
    System.gc(); //垃圾回收
    System.out.println("2 软引用类 引用 st ："+sr);
    System.out.println("2 byte[]引用类 引用  ："+sr.get());

    byte[] bytes = new byte[1024 * 1024 * 11];

    System.out.println("3 软引用类 引用 st ："+sr);
    System.out.println("3 byte[]引用类 引用  ："+sr.get());

}

打印结果：

1 软引用类 引用 st ：java.lang.ref.SoftReference@1b6d3586

1 byte[]引用类 引用 ：[B@4554617c

2 软引用类 引用 st ：java.lang.ref.SoftReference@1b6d3586

2 byte[]引用类 引用 ：[B@4554617c

3 软引用类 引用 st ：java.lang.ref.SoftReference@1b6d3586

3 byte[]引用类 引用 ：null （已经被GC回收掉了）

3 弱引用 WeakReference 弱应用引用的对象，每次GC都会回收掉！ （应用场景有ThreadLocal）

/**
 * 3.弱引用：每次GC就回收掉；
 */
public static void  weakReference(){
    WeakReference<ReferenceDemo> wr = new WeakReference<ReferenceDemo>(new ReferenceDemo());
    // 弱引用对象 wr---强引用--> 弱引用实例---- 弱引用----> 学习引用对象    学习对象实例用弱引用引用着，每次GC就会回收掉 学习引用对象（销毁）
    System.out.println("1.引用是否存在"+wr);
    System.out.println("1.学习引用对象 是否存在"+wr.get());

    sleepThread(1000);
    System.gc();
    System.out.println("2.引用是否存在"+wr);
    System.out.println("2.学习引用对象 是否存在"+wr.get());

}

打印结果：

1.引用是否存在java.lang.ref.WeakReference@1b6d3586

1.学习引用对象 是否存在com.gyj.study.referece.ReferenceDemo@4554617c

2.引用是否存在java.lang.ref.WeakReference@1b6d3586

2.学习引用对象 是否存在null

ReferenceDemod对象死亡了 （GC异步回收！）

4.虚引用 phantomReference 弱应用引用的对象，每次GC都会回收掉！ （应用场景有ThreadLocal）并且GC回收钱也获取不到

public static void phantomReference(){
    ReferenceQueue referenceQueue = new ReferenceQueue<ReferenceDemo>();
    PhantomReference<ReferenceDemo> pr = new PhantomReference<ReferenceDemo>(new ReferenceDemo(),referenceQueue);
    // 虚引用对象 pr---强引用--> 虚引用实例---- 虚引用----> 学习引用对象    学习对象实例用虚引用引用着，每次GC就会回收掉 学习引用对象（销毁）
    //虚用获取不到
    System.out.println("1.引用是否存在"+pr);
    System.out.println("1. Queue:"+referenceQueue.poll());
    System.out.println("1.学习引用对象 是否存在"+pr.get());

    sleepThread(1000);
    System.gc();
    System.out.println("2.引用是否存在"+pr);
    System.out.println("1. Queue:"+referenceQueue.poll());
    System.out.println("2.学习引用对象 是否存在"+pr.get());
    
}

结果：

1.引用是否存在java.lang.ref.PhantomReference@1b6d3586

1. Queue:null

1.学习引用对象 是否存在null

2.引用是否存在java.lang.ref.PhantomReference@1b6d3586

1. Queue:null

2.学习引用对象 是否存在null

ReferenceDemod对象死亡了

最后总结：

* java 的引用分为4中
* 1.强引用   引用存在就不会被GC
* 2.软引用   heap memory（堆内存）满了就会被GC掉
* 3.弱引用   每次GC就会回收掉（应用有：ThreadLocal）
* 4.虚引用   每次GC就会回收掉（应用有，控制jvm外的内存）