当一个对象被引用一次则计数+1，失去引用计数-1，当计数为0则判断为垃圾。但当对象间存在循环引用时(如下图)会无法被回收。
6.1.2 可达性分析算法Java中使用可达性分析算法来判断垃圾。肯定不会被垃圾回收的对象为根对象，可以经由根对象直接或间接引用的对象不会被垃圾回收，反则反之。打个比喻：连在串上的葡萄就是不可以被回收的对象，散在盘中的葡萄就是可以被垃圾回收的。
哪些对象可以作为根对象呢？使用eclipse的MAT(memory analyzer)可以进行分析。这个工具比jvisual更加专业，可以找到内存泄漏。
运行如下代码。
public class Demo2_2 {
public static void main(String[] args) throws InterruptedException, IOException {
List
使用命令jps查看当前运行代码的进程为17332。
PS F:资料 解密JVM代码jvm> jps 13472 Launcher 3296 Jps 12868 RemoteMavenServer36 17332 Demo2_2 11180
在list回收前、后分别使用jamp抓取目标进程内存的快照，转储为二进制文件，并设置live参数在抓取快照前主动触发垃圾回收。回收前的操作命令如下。
jmap -dump:format=b,live,file=gcRootDemo.bin 17332
使用elipse的MAT工具可以来分析内存泄漏问题，官网下载安装MAT，https://www.eclipse.org/mat/downloads.php。
使用MAT工具，菜单栏file->open dump file打开刚才抓取的快照文件。打开文件时报错Invalid HPROF file header,其中一个原因为人工改变了文件的编码格式，重新抓取并不要改变编码格式。将两个文件都打开以方便对照。如下图，查看文件的GC Roots。
可以看到GC Root的具体情况，被分为了4类。
System Class是程序运行所必须的核心类。
第二类是执行本地方法时操作系统所引用的Java对象的类。
Busy Monitor是指正在加锁的对象，如果这对象被回收了，则锁无法被释放，故不会被回收。
最后是活动着的线程中，局部变量所引用的对象不能被当成垃圾回收。比如下图中的ArrayList其实就是对应代码中list1被垃圾回收前所指对象，在list对象回收后的抓取的内存快照gcRootDemo2.bin中该对象不存在了。
6.2 五种引用java中有五种引用类型。
6.2.1 强引用只要沿着GC Root可以找到该对象，则不会被垃圾回收。如图中A1对象，只有当B,C对象对A1的引用都断开时，才会被垃圾回收。
6.2.2 软引用当发生垃圾回收且内存不够时，则会对其进行进行回收。如图中A2对象，当B对象的引用断开，那么进行垃圾回收且内存不够时，A2对象将会被回收。
6.2.3 弱引用当发生垃圾回收时，就会对其进行回收。如图中A3对象，当B对象的引用断开，那么进行垃圾回收，A3对象将会被回收。
特别的，软引用和弱引用本身也属于对象，可以配合引用队列进行使用。
6.2.4 虚引用虚引用与终结器引用必须配合引用对象进行使用。如前文中提到的ByteBuffer对象，会创建一个虚引用Cleaner，并且会将ByteBufer所分配的直接内存传递给Cleaner引用。当ByteBufferber对象被垃圾回收后，Cleaner会进入引用队列。ReferenceHandler会定期扫描引用队列中新入队的对象，当Cleaner被扫描到就会执行其clean()方法，调用Unsafe对象的freememory()将直接内存释放。
6.2.5 终结器引用所有对象都继承自Object，而Object中有一个finalize()方法，对象可以重写finalize()方法，在对象进行垃圾回收时该方法将被调用。但是对象已经没有强引用了，finalize()方法怎么被调用呢？其实就是通过终结器引用实现的。在B对象断开A4的强引用后，终结器引用会被加入引用队列，由一个优先级很低的finalizeHandler进行扫描，当扫描到引用队列中的终结器引用后，会执行其所引用的A4对象的finalize()方法。由于finalize()方法不会被立刻执行，而是先进行入队，并且负责扫描的finalizeHandler优先级低，可能导致finalize()迟迟得不到执行，因此不推荐使用它进行资源回收.
6.3 软引用应用配置运行下列代码，显然会报OutOfMemoryError。
public class Demo2_3 {
private static final int _4MB = 4 * 1024 * 1024;
public static void main(String[] args) throws IOException {
List list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
list.add(new byte[_4MB]);
}
}
}
而以上常见在实际编程中其实是常见的，比如在读取图片内容时。软引用可以解决这种内存占用的问题。
public static void soft() {
// list --> SoftReference --> byte[]
List> list = new ArrayList<>();
for (int i = 0; i < 5; i++) {
SoftReference ref = new SoftReference<>(new byte[_4MB]);
System.out.println(ref.get());
list.add(ref);
System.out.println(list.size());
}
System.out.println("循环结束：" + list.size());
for (SoftReference ref : list) {
System.out.println(ref.get());
}
}
以上代码中，list和SoftReference是强引用，但是SoftReference和byte[]是软引用。打印结果如下。
[B@7f31245a 1 [B@6d6f6e28 2 [B@135fbaa4 3 [B@45ee12a7 4 [B@330bedb4 5 循环结束：5 null null null null [B@330bedb4
观察到在循环结束前可以调用到bye[]数组，但是循环结束前四个数组已经变成了null。
添加虚拟机参数：-XX:+PrintGCDetails -verbose:gc，打印垃圾回收的细节与详细参数，然后再次运行查看垃圾回收完整过程。
[B@7f31245a 1 [B@6d6f6e28 2 [B@135fbaa4 3 [GC (Allocation Failure) [PSYoungGen: 2209K->488K(6144K)] 14497K->13130K(19968K), 0.0024761 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [B@45ee12a7 4 [GC (Allocation Failure) --[PSYoungGen: 4696K->4696K(6144K)] 17338K->17502K(19968K), 0.0020330 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [Full GC (Ergonomics) [PSYoungGen: 4696K->4466K(6144K)] [ParOldGen: 12806K->12675K(13824K)] 17502K->17142K(19968K), [metaspace: 3331K->3331K(1056768K)], 0.0100720 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] [GC (Allocation Failure) --[PSYoungGen: 4466K->4466K(6144K)] 17142K->17158K(19968K), 0.0024079 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] [Full GC (Allocation Failure) [PSYoungGen: 4466K->0K(6144K)] [ParOldGen: 12691K->740K(8704K)] 17158K->740K(14848K), [metaspace: 3331K->3331K(1056768K)], 0.0118198 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] [B@330bedb4 5 循环结束：5 null null null null [B@330bedb4 Heap PSYoungGen total 6144K, used 4377K [0x00000000ff980000, 0x0000000100000000, 0x0000000100000000) eden space 5632K, 77% used [0x00000000ff980000,0x00000000ffdc64f0,0x00000000fff00000) from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000) to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000) ParOldGen total 8704K, used 740K [0x00000000fec00000, 0x00000000ff480000, 0x00000000ff980000) object space 8704K, 8% used [0x00000000fec00000,0x00000000fecb90f0,0x00000000ff480000) metaspace used 3352K, capacity 4500K, committed 4864K, reserved 1056768K class space used 359K, capacity 388K, committed 512K, reserved 1048576K
观察到在第三个循环结束后，内存已经快不足，进行了新生代回收。在第四个循环结束后，又进行了一次新生代的回收，但是效果不理想(4696K->4696K),于是触发了一次Full GC。由于进行垃圾回收且内存仍然不足，又触发了一次新的垃圾回收，将软引用所引用的对象释放。像缓存的图片等不重要的对象，可以通过软引用来引用，当内存空间不足时就会回收它们。
同时我们也注意到，前四个软引用所指的对象已经是null了，没有必要再把这四个软引用保留在list集合中。可以配合引用队列来完成软引用的回收。
public static void soft() {
// list --> SoftReference --> byte[]
List> list = new ArrayList<>();
ReferenceQueue referenceQueue = new ReferenceQueue<>();
for (int i = 0; i < 5; i++) {
SoftReference ref = new SoftReference<>(new byte[_4MB], referenceQueue);
System.out.println(ref.get());
list.add(ref);
System.out.println(list.size());
}
Reference poll = referenceQueue.poll();
while (poll != null) {
list.remove(poll);
poll = referenceQueue.poll();
}
System.out.println("循环结束：" + list.size());
for (SoftReference ref : list) {
System.out.println(ref.get());
}
}
结果如下。
[B@7f31245a 1 [B@6d6f6e28 2 [B@135fbaa4 3 [B@45ee12a7 4 [B@330bedb4 5 循环结束：1 [B@330bedb4 Process finished with exit code 06.4 弱引用
与软引用十分类似。
public class Demo2_5 {
private static final int _4MB = 4 * 1024 * 1024;
public static void main(String[] args) {
// list --> WeakReference --> byte[]
List> list = new ArrayList<>();
for (int i = 0; i < 10; i++) {
WeakReference ref = new WeakReference<>(new byte[_4MB]);
list.add(ref);
for (WeakReference w : list) {
System.out.print(w.get()+" ");
}
System.out.println();
}
System.out.println("循环结束：" + list.size());
}
}
打印的结果如下。其中第10 次循环时，由于弱引用本身也占有一定的内存，触发Full GC。
[B@7f31245a [B@7f31245a [B@6d6f6e28 [B@7f31245a [B@6d6f6e28 [B@135fbaa4 [GC (Allocation Failure) [PSYoungGen: 2209K->504K(6144K)] 14497K->13139K(19968K), 0.0023913 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [B@7f31245a [B@6d6f6e28 [B@135fbaa4 [B@45ee12a7 [GC (Allocation Failure) [PSYoungGen: 4712K->496K(6144K)] 17347K->13326K(19968K), 0.0025155 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [B@7f31245a [B@6d6f6e28 [B@135fbaa4 null [B@330bedb4 [GC (Allocation Failure) [PSYoungGen: 4704K->504K(6144K)] 17534K->13350K(19968K), 0.0020861 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] [B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null [B@2503dbd3 [GC (Allocation Failure) [PSYoungGen: 4711K->504K(6144K)] 17557K->13382K(19968K), 0.0017767 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null null [B@4b67cf4d [GC (Allocation Failure) [PSYoungGen: 4710K->456K(6144K)] 17588K->13334K(19968K), 0.0017985 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null null null [B@7ea987ac [GC (Allocation Failure) [PSYoungGen: 4775K->504K(5120K)] 17653K->13398K(18944K), 0.0011480 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [B@7f31245a [B@6d6f6e28 [B@135fbaa4 null null null null null [B@12a3a380 [GC (Allocation Failure) [PSYoungGen: 4735K->256K(5632K)] 17629K->13531K(19456K), 0.0016537 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] [Full GC (Ergonomics) [PSYoungGen: 256K->0K(5632K)] [ParOldGen: 13275K->782K(8192K)] 13531K->782K(13824K), [metaspace: 3345K->3345K(1056768K)], 0.0108212 secs] [Times: user=0.17 sys=0.00, real=0.01 secs] null null null null null null null null null [B@29453f44 循环结束：10
当然，弱引用与软引用的区别是，只要触发垃圾回收，无论内存是否充足都会回收其引用对象。
public class WeakReferenceDemo {
public static void main(String[] args) {
WeakReference sr = new WeakReference( new String( "hello" ));
System.out.println(sr.get());
System.gc(); //通知JVM的gc进行垃圾回收
System.out.println(sr.get());
}
}
输出结果。
hello null6.5 回收算法 6.5.1 标记清除算法
先标记(将不可被GC Root直接或者间接访问的内存标记)，再清除(并不是做清零操作，而是被空闲的内存起始地址放入空闲内存表，下次分配内存时就可以使用)。这种方式的优点是速度快，缺点是容易产生内存碎片，比如存储一个数组对象，总的内存空间足够，但是内存不连续，依然会导致内存溢出问题。
6.5.2 标记整理算法先标记，再整理(移动对象)。优点是内存连续，缺点是消耗一定的时间，（对象移动，同时对象的地址发生变化，如果对象有引用，那么引用中保存的地址也需要随之发生改变。）
6.5.3 复制算法先标记，后复制。将对象从from移动到to区域，在移动过程中就完成了内存整理工作。同时交换from和to区。优点是空间连续，缺点是需要使用双倍的内存空间。
6.6 分代回收机制JVM同时综合使用了三种垃圾回收算法。这就是分代回收机制。
内存空间可以分为新生代和老年代，新生代又可以分为伊甸园和幸存者from，幸存者to。之所以采用分代回收机制，是为了使不同的垃圾回收策略。新生代用于存放朝生夕死的对象，会频繁的进行垃圾清理。
一个对象被创建后，首先会放入新生代的伊甸园中。
当新生区内存无法放入新的对象时，会触发一次Minor GC，将根据根可达算法判断伊甸园和幸存区From中哪些对象可以被回收，对于没有被垃圾回收的对象，根据复制算法将其复制到幸存区to中，交换幸存区From和幸存区To，并将未被回收对象寿命增1。Minor GC会引发STW(Stop the world)，即进行垃圾回收时其他用户线程会被暂停。之所以要触发STW是因为垃圾回收的过程中会改变对象的地址，如果不暂停其他线程，当其他线程找不到对象会发生混乱。因为大部分对象都会被垃圾回收，需要通过复制算法改变内存地址的对象并不多，Minor GC的SWT较短。
当幸存区中的对象寿命到了阈值(最大为15{4bit}），说明这些对象的生命周期较长，这些对象将会被移到老年代中，当内存资源较为紧张，新生代存放不下更多对象，也可能将对象移到老年代中。老年代的垃圾回收频率较低。
如果堆中新生代快满了，放不进新的对象，同时老年代也快满了，会先尝试触发Minor GC，空间仍然不足就会触发Full GC。对整个堆进行垃圾回收。因为Full GC时老年代的回收算法耗时，同时要回收的对象数量较多，Full GC的SWT时间较长。如果Full GC后内存仍然不足就会触发Out of Memory。
6.7 GC分析下面我们通过实例对GC的过程分析。开始GC分析之前，先了解一些GC常用的一些参数。其中上表中的晋升是指新生代晋升到老年代。
参考下面代码，设置参数并运行。其中参数-XX:+UserSerialGC是将垃圾回收器设置为UserSerialGC，这种垃圾回收器的幸存区不会进行自动调整，有助于我们观察现象。
public class Demo2_1 {
private static final int _512KB = 512 * 1024;
private static final int _1MB = 1024 * 1024;
private static final int _6MB = 6 * 1024 * 1024;
private static final int _7MB = 7 * 1024 * 1024;
private static final int _8MB = 8 * 1024 * 1024;
// -Xms20M -Xmx20M -Xmn10M -XX:+UseSerialGC -XX:+PrintGCDetails -verbose:gc -XX:-ScavengeBeforeFullGC
public static void main(String[] args) throws InterruptedException {
}
}
打印信息如下。
Heap def new generation total 9216K, used 2311K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000) eden space 8192K, 28% used [0x00000000fec00000, 0x00000000fee41d50, 0x00000000ff400000) from space 1024K, 0% used [0x00000000ff400000, 0x00000000ff400000, 0x00000000ff500000) to space 1024K, 0% used [0x00000000ff500000, 0x00000000ff500000, 0x00000000ff600000) tenured generation total 10240K, used 0K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000) the space 10240K, 0% used [0x00000000ff600000, 0x00000000ff600000, 0x00000000ff600200, 0x0000000100000000) metaspace used 3268K, capacity 4496K, committed 4864K, reserved 1056768K class space used 347K, capacity 388K, committed 512K, reserved 1048576K
观察到我们分配的新生代内存是10M，但是打印的只有9M，这是因为伊甸园占用8M，幸存区From和To各占用1M，JVM认为幸存区中的内存始终有一块空间是需要空着的，不能存放内容，所以这部分空间没有被计算进来。
新生代的伊甸园只有8M内存，其中28%还已经被占用了，新增以下代码。
