Java强引用，软引用，弱引用

强引用

一般我们声明变量都是强引用，如：int[] array1 =  getArray();

-Xmx10M -XX:+PrintGCDetails

package com.fen.dou;

public class YInyong {
    public static void main(String[] args) throws InterruptedException {
        int[] array1 =  getArray();
        int[] array2 =  getArray();
    }
    public static int[] getArray(){
        int[] obj = new int[1024*1024];
        int i = 0;
        while (i < 1024*1024){
            obj[i] = (int)(Math.random()*100+1);
            i++;
        }
        return obj;
    }
}

 new int[1024*1024]中添加int数值类型的数据，一个int是4个字节，则 int[] array1 =  getArray();中的数组大小是4*1024*1024 bytes = 4M，

[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] [ParOldGen: 5134K->5114K(7168K)] 5134K->5114K(9728K)......

看此时老年代，full gc之后，占用内存5114K，7168K是老年代最大的内存大小，剩余内存7168K-5114K< 4*1024K，放不下第二个4M的数组，则抛出堆溢出，所以强引用的对象，在JVM full gc不能回收，那怎么让以后不再用的强引用的对象进行回收呢？

 1、显示把引用置为null：array1=null;

package com.fen.dou;

public class YInyong {
    public static void main(String[] args) throws InterruptedException {
        int[] array1 =  getArray();
         //处理业务逻辑
         array1=null;
         Thread.sleep(1);//如果不加这个，不会进行回收，我想是gc存在一定的回收时间及周期
         int[] array2 =  getArray();
         //处理业务逻辑

    }
    public static int[] getArray(){
        int[] obj = new int[1024*1024];
        int i = 0;
        while (i < 1024*1024){
            obj[i] = (int)(Math.random()*100+1);
            i++;
        }
        return obj;
    }
}

[Full GC (Allocation Failure) [PSYoungGen: 512K->0K(2560K)] [ParOldGen: 4975K->1102K(5632K)] 5487K->1102K(8192K),.......

此时 5632K-1102K=4530K>4096K，可以存放第二个4M的数组，则第一个4M的数组已经被GC掉了

2、每个大对象用单独的方法来处理：

public class YInyong {
    public static void main(String[] args) throws InterruptedException {

        processArray1();
        processArray2();
    
    }

    static void processArray1(){
        int[] array1 =  getArray();
        //处理业务逻辑
    }
    static void processArray2(){
        int[] array2 =  getArray();
        //处理业务逻辑
    }
    public static int[] getArray(){
        int[] obj = new int[1024*1024];
        int i = 0;
        while (i < 1024*1024){
            obj[i] = (int)(Math.random()*100+1);
            i++;
        }
        return obj;
    }
}

 我们知道，在栈中每个方法一个栈帧，则processArray1执行完之后，栈帧就退出了，则引用就失效了，从而processArray1方法中引用的实例也会被GC掉

总结：

强引用，JVM在运行中，当前线程栈帧没有退出，则栈帧里面的引用会一直存在，则引用对应的实例，就算内存溢出都不会被GC

如果想让强引用的实例被GC有两种方式：

1、显示把引用置为null，并预留一点时间用于gc

2、每一个大对象用单独的方法进行处理

软引用

 还是用上述的程序：

package com.fen.dou;

import java.lang.ref.SoftReference;

public class YInyong {
    public static void main(String[] args) throws InterruptedException {

        SoftReference<int[]> sr = new SoftReference<int[]>(getArray());
        System.out.println(sr.get().length);
        //处理业务逻辑
        int[] array2 =  getArray();
        //处理业务逻辑
        System.out.println(sr.get());
    }


    public static int[] getArray(){
        int[] obj = new int[1024*1024];
        int i = 0;
        while (i < 1024*1024){
            obj[i] = (int)(Math.random()*100+1);
            i++;
        }
        return obj;
    }
}

 看第一个4M数组，用SoftReference包装了一下，在第二个4M大数组，分配内存的时候，由于老年代空间不足，则会进行full gc，此时发现gc后，堆中老年代还是不足，不足以放下第二个4M大数组，此时会再次进行full gc 把软引用的实例GC掉，出现两个full gc

 总结：

软引用，如果一旦内存不足，则会触发full gc回收软引用的实例，尽可能的防止内存溢出

切记，如果当前线程一直在运行，SoftReference<int[]> sr = new SoftReference<int[]>(getArray());中如果sr不再用了，则应把sr=null，否则getArray()如果已经被GC掉了，new SoftReference()也就没任何意义了，会造成内存泄漏

弱引用

  还是用上述的程序：把4M大数组改成2M数组

public class YInyong {
    public static void main(String[] args) throws InterruptedException {
        WeakReference<int[]> wr = new WeakReference<int[]>(getArray());
        System.out.println(wr.get().length);
        //处理业务逻辑
        int[] array2 =  getArray();
        System.out.println(wr.get());
        //处理业务逻辑
    }


    public static int[] getArray(){
        int[] obj = new int[1024*512];
        int i = 0;
        while (i < 1024*512){
            obj[i] = (int)(Math.random()*100+1);
            i++;
        }
        return obj;
    }
}

 

注意此时：老年代使用是used 4882K，没有出现full gc，因为老年代7168K足以放下2个2M的数组， 在没有出现gc的情况的，我怎么才能把使用过的大数组给gc掉呢？，防止内存泄漏导致的内存溢出,加System.gc();

public class YInyong {
    public static void main(String[] args) throws InterruptedException {
        WeakReference<int[]> wr = new WeakReference<int[]>(getArray());
        System.out.println(wr.get().length);
        //处理业务逻辑
        System.gc();
        int[] array2 =  getArray();
        //处理业务逻辑
        System.out.println(wr.get());
    }
    public static int[] getArray(){
        int[] obj = new int[1024*512];
        int i = 0;
        while (i < 1024*512){
            obj[i] = (int)(Math.random()*100+1);
            i++;
        }
        return obj;
    }
}

看此时：老年代使用是used 3058K，比之前的4882K明显变小了

总结：

弱引用是JVM出现full  gc的时候，会被回收（不单单是内存不足）

 切记，如果当前线程一直在运行，WeakReference<int[]> wr = new WeakReference<int[]>(getArray());中如果wr不再用了，则应把wr=null，否则getArray()如果已经被GC掉了，new WeakReference()也就没任何意义了，会造成内存泄漏

对比（线程一直在运行状态的情况下）：

强引用的实例：栈帧退出或者引用强制置为null后会被GC掉

软引用的实例：内存不足时，会被GC掉

弱引用的实例：JVM发生full gc时，会被gc掉