JVM-垃圾回收相关概念

垃圾回收相关概念（学习笔记）

System.gc() 的理解

在默认情况下，通过System.gc()或者Runtime.getRuntime.gc()的调用，会显示触发Full GC，同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。
然后System.gc()调用附带一个免责声明，无法保证对垃圾收集器的调用。
一般情况下，垃圾回收是自动进行的，无需手动触发。在一些特殊情况下，如我们正在编写一个性能测试，我们可以在测试之前调用System.gc()。

理解不可达对象的回收

例子1：

public void localvarGC1() {
	byte[] buffer = new byte[10 * 1024 * 1024];//10MB
	System.gc();
}

显然，创建的字节数组不会被回收。

例子2：

public void localvarGC2() {
	byte[] buffer = new byte[10 * 1024 * 1024];
	buffer = null;
	System.gc();
}

显然，创建的字节数组会被回收。

例子3：

public void localvarGC3() {
    {
        byte[] buffer = new byte[10 * 1024 * 1024];
    }
    System.gc();
}

注意，创建的字节数组不会被回收。
解释：在此方法中，局部变量表的长度为2，第一个变量指向的是this，第二个变量在byte[] buffer = new byte[10 * 1024 * 1024];处指向了被创建的数组。当代码运行到System.gc();时，局部变量中依然存在指向数组的指针，因此该数组不能被回收。

例子4：

public void localvarGC4() {
    {
        byte[] buffer = new byte[10 * 1024 * 1024];
    }
    int value = 10;
    System.gc();
}

注意，创建的字节数组会被回收。
解释：在此方法中，局部变量表的长度依然为2，第一个变量指向的是this，第二个变量在byte[] buffer = new byte[10 * 1024 * 1024];处指向了被创建的数组。但是，当代码运行到int value = 10;处时，局部变量表中的第二个变量会被修改为10（buffer的作用域结束，局部变量表被复用）。因此，当代码运行到System.gc();时，局部变量中已经不存在指向数组的指针，因此该数组可以被回收。

例子5：

public void localvarGC5() {
    localvarGC1();
    System.gc();
}

显然，localvarGC1()中创建的字节数组会被回收。

内存溢出（OOM）

javadoc中，OOM是指没有空闲内存，并且垃圾收集器也无法提供更多内存。
在OOM之前，JVM通常会来一次独占式的Full GC。（特殊情况：需要去分分配一个超大对象，对象需要的空间大小已经超过了堆的最大值）
所有一般情况下，除非应用程序占用的内存增长速度非常快，造成垃圾回收已经跟不上内存消耗的速度，否则不太容易出现OOM的情况。
通常造成OOM的原因有二：

1. JVM的堆内存设置不够（也可能穿在内存泄漏的问题）；
2. 代码中创建了大量的大对象，并且长时间不能被回收。

内存泄漏（Memory Leak）

严格上说，只有对象不会在被程序用到了，但是GC有不能回收时，才叫内存泄漏。
但实际情况时，由于不太好的实践会导致对象的生命周期变得很长甚至导致OOM，则叫做宽泛意义上的“内存泄漏”。

注意：引用计数算法中的循环引用在java中不算做内存泄漏。

内存泄漏的例子

1. 单例模式
   单例的生命周期和应用程序一样长。如果单例程序中持有堆外部对象的引用的话，该外部对象不能够被回收，则会导致内存泄漏的产生。
2. 一些提供close的资源没有关闭
   数据库连接、网络连接和IO连接必须手动close()，否则时不能被回收的。

STW（Stop-the-World）

STW是指GC事件发生过程中，会产生应用程序的停顿，应用程序线程会被暂停，没有任何响应，类似卡死的状态。
可达性分析工作必须在一个能够保证一致性的快照中进行，否则分析结果的准确性无法保证。
频繁的中断会降低用户体验，所以我们需要减少STW发生的频率。
STW事件和哪款GC无关，所有的GC 都会有这个事件。
STW时JVM在后台自动发起和自动完成的。在用户不可见的情况下，把用户正常的工作线程全部停掉。
开发中不要用System.gc()，它会导致STW的发生。

体验STW

例子1：编写一个线程，让程序每隔1秒钟打印1次。

public class StopTheWorldDemo {

    public static class PrintThread extends Thread {
        public final long startTime = System.currentTimeMillis();

        @Override
        public void run() {
            try {
                while (true) {
                    // 每秒打印时间信息
                    long t = System.currentTimeMillis() - startTime;
                    System.out.println(t / 1000 + "’" + t % 1000);
                    Thread.sleep(1000);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        PrintThread p = new PrintThread();
        p.start();
    }
}

从结果上看，应用程序基本上时每隔一秒钟打印一次，符合预期。

0‘0
1’0
2‘1
3’2
4‘2
5’2

例子2：在例子1的基础上加入一个工作线程，不断地创建字节数组放入到列表中，并在一定列表装满一半之后请理列表并显示地调用GC。

public class StopTheWorldDemo {
    public static class WorkThread extends Thread {
        List<byte[]> list = new ArrayList<byte[]>();

        @Override
        public void run() {
            try {
                while (true) {
                    for(int i = 0;i < 1000;i++){
                        byte[] buffer = new byte[1024];
                        list.add(buffer);
                    }

                    if(list.size() > 10000){
                        list.clear();
                        System.gc();//会触发full gc，进而会出现STW事件
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    public static class PrintThread extends Thread {
        public final long startTime = System.currentTimeMillis();

        @Override
        public void run() {
            try {
                while (true) {
                    // 每秒打印时间信息
                    long t = System.currentTimeMillis() - startTime;
                    System.out.println(t / 1000 + "‘" + t % 1000);
                    Thread.sleep(1000);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        WorkThread w = new WorkThread();
        PrintThread p = new PrintThread();
        w.start();
        p.start();
    }
}

结果如下，打印的时间不再贴合1秒1次的规律。

0‘2
1’5
2‘6
3’9
4‘9
5’12

这说明STW会让用户线程发生停顿。

并行与并发

程序的并发（Concurrent）

在操作系统中，是指一个时间段中有几个程序都已处于一运行到运行完毕之间，且这几个程序都是在同一个处理器上运行。
并发不是真正意义上的“同时进行”，只是CPU把一个时间段划分为几个时间片段，并且在其中来回切换。由于CPU 处理速度非常快，只要时间间隔处理得当，即可让用户感觉多个应用程序时同时运行的。

程序的并行（Parallel）

当系统有一个以上的CPU，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，我们称之为并行。
决定并行的并非CPU数量，而是CPU的核心数量。
适合科学计算，后台处理等弱交互场景。

并发与并行的对比

	特点	互相抢占资源
并发	一个时间段内同时发生	是
并行	一个时间点上同时发生	否

垃圾回收的并行与并发

串行：单线程执行垃圾收集工作。
并行：多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态。

• 例如：ParNew、Parallel Scavenge、Parallel Old。

并发：指垃圾回收线程与用户线程同时执行（但这两个线程并非是并行的，有可能是交替执行），垃圾回收线程执行时不会停顿用户线程的运行。

• 例如：CMS、G1。

安全点和安全区域

安全点

程序执行时，并非在所有地方都能够停顿下来开始GC，只有在特定位置才能停顿下来开始GC，这样的位置称为“安全点”（Safe Point）。
安全点的选择很重要，如果太少可能导致GC等待时间太长，如果太多可能导致运行时的性能问题。
选择的标准：选择一些执行时间较长的指令作为安全点，如方法调用、循环跳转和异常跳转等。
如何在GC时，检查所有线程都跑到最近的安全点停顿下来？

• 抢先式中断（目前虚拟机不再使用）：首先中断所有线程。如果还有线程不再安全点，就恢复线程，让线程跑到安全点。
• 主动式中断：设置一个中断标志，各个线程运行到安全点时主动轮询这个标志，如果中断标志为真，则将自己进行中断挂起。

安全区域

安全点机制保证了程序执行时，在不太长的时间内就会遇到可进入GC的模式。
但是如果线程处于Sleep状态或Blocked状态等不执行的状态时，线程无法响应JVM的中断请求，也无法“走”到安全点中断挂起，JVM也不太可能等待线程被唤醒。对于这种情况，就需要“安全区域”（Safe Region）来解决。

安全区域时指在一段代码片段中，对象的引用关系不会发生变化，在这个区域中的任何位置开始GC都是安全的。
我们也可以把安全区域看成时扩展了的安全点。

实际执行时：

1. 当线程运行到安全区域的代码时，首先表示已经进入到安全区域，如果这段时间内发生了GC，JVM会忽略标识为安全区域状态的线程；
2. 当线程即将离开安全区域时，会检查JVM是否已经完成了GC，如果完成了，则继续运行，否则线程必须等待直到收到可以离开安全区域的信号为止。

Java中引用的类别

我们希望能够描述这样一类对象：内存空间足够时，则能够保留在内存中；如果内存空间在进行垃圾收集后还是很紧张，则可以抛弃这些对象。
JDK 1.2后，Java对引用概念进行了扩充，分为强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference），则4中引用的强度逐渐减弱。

其中，终结器引用（FinalReference）是包内可见的，其他三种都是public，可以在应用程序中之直接使用。

四种引用的区别

• 强引用：最传统的引用的定义。无论任何情况下，只要强引用关系还在，垃圾收集器就永远不会回收掉被引用的对象。
• 软引用：在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常。
• 弱引用：被弱引用关联的对象只能生存到下一次垃圾回收之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联的对象。
• 虚引用：一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被回收时收到一个系统通知。

四种引用的应用场景

• 强引用：绝大部分情况下，都是使用的强引用，也是默认的引用类型
• 软引用：系统缓存情况下会使用
• 弱引用：系统缓存情况下会使用
• 虚引用：对象回收的跟踪

强引用

虚拟机宁可抛出OOM异常，也不会回收强引用说指向的对象。
强引用可能导致内存泄漏。

软引用：内存不足即回收

软引用时用来描述一些还有用，但非必需的对象。在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常。
软引用通常用来实现内存敏感的缓存。
垃圾回收器在某个时刻决定回收软可达对象时，会请理软引用，并可选地把引用存放到一个引用队列中。
JVM会尽量让软引用的存活时间长一些，迫不得已才清理。

设置软引用的语法如下：

SoftReference<Object> userSoftRef = new SoftReference<Object>(new Object());//创建软引用

或

Object obj = new Object();//声明强引用
SoftReference<Object> userSoftRef = new SoftReference<Object>(obj);//创建软引用
obj = null;//取消强引用

注意：obj = null;这步必不可少，否则创建出的对象依然保有一个强引用。

代码演示

// 参数：-Xms10m -Xmx10m -XX:+PrintGCDetails
public class SoftReferenceTest {
    public static class User {
        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        public int id;
        public String name;

        @Override
        public String toString() {
            return "[id=" + id + ", name=" + name + "] ";
        }
    }

    public static void main(String[] args) {
        //创建对象，建立软引用
//        SoftReference<User> userSoftRef = new SoftReference<User>(new User(1, "songhk"));
        //上面的一行代码，等价于如下的三行代码
        User u1 = new User(1,"songhk");
        SoftReference<User> userSoftRef = new SoftReference<User>(u1);
        u1 = null;//取消强引用


        //从软引用中重新获得强引用对象
        System.out.println(userSoftRef.get());

        System.gc();
        System.out.println("After GC:");
//        //垃圾回收之后获得软引用中的对象
        System.out.println(userSoftRef.get());//由于堆空间内存足够，所有不会回收软引用的可达对象。
//
        try {
            //让系统认为内存资源紧张、不够
            byte[] b = new byte[1024 * 1024 * 8];
//            byte[] b = new byte[1024 * 7168 - 635 * 1024];
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            //再次从软引用中获取数据
            System.out.println(userSoftRef.get());//在报OOM之前，垃圾回收器会回收软引用的可达对象。
        }
    }
}

弱引用：发现即回收

弱引用也被用来描述非必须对象，非常适合用来保存哪些可有可无的缓存。
只被弱引用关联的对象只能生存到下一次垃圾回收发生为止。
由于垃圾回收的线程通常优先级很低，因此，并不宜能能够很快地发现持有弱引用的对象。在这种情况下，弱引用对象可以存在较长的时间。
拓展：WeakHashMap

虚引用：对象回收跟踪

虚引用也称为幽灵引用或幻影引用。
一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。
它不能单独地使用，也无法通过虚引用来获取被引用的对象。当试图通过虚引用的get()方法取得对象时，返回结果总是null。
为一个对象设置虚引用关联的唯一目的就是追踪垃圾回收过程，比如在这个对象被回收时收到一个系统通知。

创建虚引用

虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器整备回收一个对象时，如果发现它还有虚引用，就会在回收对象后，将这个虚引用加入队列，以通知应用程序对象的回收情况。

ReferenceQueue phantomQueue = new ReferenceQueue();
PhantomReference<Object> pf = new PhantomReference<>(new Object(),phantomQueue);

由于虚引用可以跟踪对象的回收时间，因此，也可以将一些资源释放操作放置在虚引用中执行和记录。

代码演示

public class PhantomReferenceTest {
    public static PhantomReferenceTest obj;//当前类对象的声明
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null;//引用队列

    public static class CheckRefQueue extends Thread {
        @Override
        public void run() {
            while (true) {
                if (phantomQueue != null) {
                    PhantomReference<PhantomReferenceTest> objt = null;
                    try {
                        objt = (PhantomReference<PhantomReferenceTest>) phantomQueue.remove();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (objt != null) {
                        System.out.println("追踪垃圾回收过程：PhantomReferenceTest实例被GC了");
                    }
                }
            }
        }
    }

    @Override
    protected void finalize() throws Throwable { //finalize()方法只能被调用一次！
        super.finalize();
        System.out.println("调用当前类的finalize()方法");
        obj = this;
    }

    public static void main(String[] args) {
        Thread t = new CheckRefQueue();
        t.setDaemon(true);//设置为守护线程：当程序中没有非守护线程时，守护线程也就执行结束。
        t.start();

        phantomQueue = new ReferenceQueue<PhantomReferenceTest>();
        obj = new PhantomReferenceTest();
        //构造了 PhantomReferenceTest 对象的虚引用，并指定了引用队列
        PhantomReference<PhantomReferenceTest> phantomRef = new PhantomReference<PhantomReferenceTest>(obj, phantomQueue);

        try {
            //不可获取虚引用中的对象
            System.out.println(phantomRef.get());

            //将强引用去除
            obj = null;
            //第一次进行GC,由于对象可复活，GC无法回收该对象
            System.gc();
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 可用");
            }
            System.out.println("第 2 次 gc");
            obj = null;
            System.gc(); //一旦将obj对象回收，就会将此虚引用存放到引用队列中。
            Thread.sleep(1000);
            if (obj == null) {
                System.out.println("obj 是 null");
            } else {
                System.out.println("obj 可用");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

终结器引用（Final Reference）

它用以实现对象的finalize()方法。
无需手动编码，其内部配合引用队列使用。
在GC时，终结器引用入队。由Finalizer线程通过终结器引用找到被引用对象并调用它们的finalize()方法，第二次GC 时才能够回收被引用的对象。