强引用
一般我们声明变量都是强引用，如：int[] array1 = ?getArray();
-Xmx10M -XX:+PrintGCDetailspackage 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掉
