垃圾回收相关概念

最新推荐文章于 2024-11-13 22:08:53 发布

~Rookie~Newbie~Noob~

最新推荐文章于 2024-11-13 22:08:53 发布

阅读量91

点赞数

分类专栏： JVM 文章标签：后端 jvm java

本文链接：https://blog.csdn.net/weixin_32196893/article/details/120948168

版权

JVM 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

System.gc()的理解

在默认情况下，通过System.gc()或者Runtime.getRuntime().gc()的调用，会显式触发Full GC，同时堆老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。
JVM实现者可以通过System.gc()调用来决定JVM的GC行为。而一般情况下，垃圾回收应该是自动进行的，无须手动触发，否则太过于麻烦了。

代码1：

public class SystemGCTest {

    public static void main(String[] args) {

        new SystemGCTest();
        System.gc(); // 提醒JVM的垃圾回收器执行gc，但是不确定是否马上执行GC
        // 与　Runtime.getRuntime().gc(); 的作用一样
        // System.runFinalization();
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("SystemGCTest rewrite finalize()");
    }
}

该代码表明，调用System.gc()，并不一定会触发finalize()方法的调用。从而也说明，System.gc()方法的调用，并不确定会马上执行GC。而System.runFinalization()方法的调用，一定会触发finalize()方法的执行。

代码2：

public class LocalVarGC {

    public void localvarGC1() {
        byte[] buffer = new byte[10 * 1024 * 1024];
        System.gc(); // 这里这些gc, 分配的内存没有被回收，因为有buffer引用指向
    }

    public void localvarGC2() {
        byte[] buffer = new byte[10 * 1024 * 1024];
        buffer = null; // 这里buffer不指向任何地方
        System.gc(); // 由于byte数组不再被任何引用指向，所以这里执行垃圾回收，会回收到10M空间
    }

    public void localvarGC3() {
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        System.gc(); // 这里发生gc，但是没有回收被buffer指向的10M空间
    }

    public void localvarGC4() {
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        int value = 10;
        System.gc();// 这里发生GC, buffer指向的10M空间被回收的
    }

    public void localvarGC5() {
        localvarGC1();
        System.gc();
        // 两次gc，第一次gc时，buffer执行的内存空间没有被回收
        // 第二次gc时，buffer指向的内存空间被回收了，原因是buffer的作用域是localvarGC1()方法
    }

    public static void main(String[] args) {
        LocalVarGC local = new LocalVarGC();
        local.localvarGC5();
    }
}

在运行程序前，加入参数-XX:+PrintGCDetails。
localvarGC3() 方法执行后，发现10M的空间没有被回收，而localvarGC4()方法执行后，10M的空间被回收了。究其原因，需要从字节码角度分析。槽位1被value变量占用了，代码块中的buffer指向null，导致10M空间回收。

localvarGC3()方法的字节码：
在这里插入图片描述

我们看到 Maximum local variables的长度是2，但是LocalVariableTable中只有一个元素this。这也就表明，buffer原先是占用槽位1，但是由于是在局部代码块中，出了代码块后，在LocalVariableTable中看不到buffer，其实实际还是占用槽位1的，因此buffer指向的内存空间，在gc时，得不到回收。

localvarGC4()方法的字节码：
在这里插入图片描述

我们发现，LocalVariableTable中槽1的位置，被value变量占用。这也就是说，原先buffer占用的槽位1，被value占用了。此时的buffer就为null，因此其原先指向的10M空间，不再被任何引用指向。所以再执行垃圾回收的时候，10M空间被回收了。

内存的溢出和内存的泄漏

内存溢出

内存溢出相对于内存泄漏来说，尽管更容易被理解，但是同样的，内存溢出也是引发程序崩溃的罪魁祸首之一。
由于GC一直发展，所有的情况下，除非应用程序占用的内存增长速度非常快，造成垃圾回收已经跟不上内存消耗的速度，否则不太容易出现OOM的情况。
大多数情况下，GC会进行各种年龄段的垃圾回收，实在不行就会进行Full GC操作，这时会回收大量的内存，供应用程序使用。
Javadoc中堆OutOfMemoryError的解释是，没有空闲内存，并且垃圾收集器也无法提供更多的内存。

没有空闲内存的情况

java虚拟机的堆内存设置不够
比如：可能存在内存泄漏问题；也有可能就是堆的大小不合理，比如我们要处理比较多的数据量，但是没有显式指定JVM堆大小或者指定的数值偏小。我们可以通过参数-Xms、-Xmx来调整。
代码中创建了大量的大对象，并且长时间不能被垃圾收集器收集（存在被引用）。
对于老版本的Oracle JDK，因为永久代的大小是有限的，并且JVM对永久代垃圾回收（如常量池回收、卸载不再需要的类型）非常不积极，所以当我们不断添加新类型的时候，永久代出现OutOfMemoryError也非常常见，尤其是再运行时存在大量动态类型生成的场合；类似intern字符串缓存占用太多空间，也会导致OOM问题。
随着元数据区的引入，方法区内存以及不再那么窘迫，所以相应的OOM有所改观。不过，直接内存不足，也会导致OOM。

OutOfMemoryError之前的动作

在抛出OutOfMemoryError之前，JVM会尽其所能清理出空间。
1. 在引用机制分析中，涉及到JVM会尝试回收软引用指向的对象。
2. 在Java.nio.BIts.reserveMemory()方法中，我们能清楚的看到，System.gc()会被调用，以清理空间。
当然，并不是任何情况，垃圾都会被触发。比如，我们分配一个超大的对象，超过堆空间的最大值，JVM可以判断出垃圾收集并不能解决这个问题，所以直接抛出OutOfMemoryError。

内存泄漏

在这里插入图片描述

只有对象不再被程序使用，但是GC又不能回收他们的情况，才叫内存泄漏。但是实际情况时，很多时候一些不太好的实践（或疏忽）会导致对象的生命周期变得很长甚至导致OOM，也可以叫做宽泛意义上的”内存泄漏“。尽管内存泄漏不会立刻引起程序崩溃，但是一旦发生内存泄漏，程序中的可用内存就会逐渐被蚕食，直至耗尽所有内存，最终出现OutOfMemory异常，导致程序崩溃。

宽泛意义的内存泄漏：如果局部变量被定义成全局变量，导致变量生命周期变长，甚至定义成类变量，随着类的加载和卸载而生存和消亡。

内存泄漏举例

单例模式下，单例的生命周期和应用程序是一样长的，所以单例程序中，如果持有对外部对象的引用的话，那么这个外部对象是不能被回收的，则会导致内存泄漏的产生。
一些提供了close()方法的资源未关闭导致内存泄漏。数据库连接，网络连接和io连接必须手动close，否则不能被回收。

Stop The World

Stop-The-World简称STW，指的是GC事件发生过程中，会产生应用程序的停顿。停顿产生时整个应用程序线程都会被暂停，没有任何响应，有点像卡死的感觉，这个停顿称为STW。
可达性分析算法中枚举根节点（GC Roots）会导致所有Java执行线程停顿。
1. 分析工作必须在一个能确保一致性的快照中进行。
2. 一致性指整个分析期间整个执行系统看起来像被冻结在某个时间点上。
3. 如果出现分析过程中对象引用关系还在不断变化，则分析结果的准确性无法保证。
被STW中断的应用程序线程会在完成GC之后恢复，频繁中断会让用户感觉像是网速不快造成电影卡带一样，所以我们需要减少STW的发生。
STW事件和采用哪款GC无关，所有的GC都有这个事件。
G1也不能完全避免STW情况的发生，只能说垃圾回收器越来越优秀，回收效率越来越高，可能地缩短了暂停时间。
STW是JVM在后台自动发起和自动完成的。在用户不可见的情况下，把用户正常的工作线程全部停掉。
开发中不要使用System.gc()，因为会导致STW的发生。

如何证明STW的存在

两个线程，一个线程每隔1秒，打印一次数据，并且记录下时间间隔；第二个线程调用System.gc()，强制发生Full GC。

代码：

import java.util.ArrayList;
import java.util.List;

public class STWDemo {

    public static class WorkThread extends Thread {

        List<byte[]> list = new ArrayList<>();

        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();
                    }
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }


    public static class PrintThread extends Thread {

        public final long startTime = System.currentTimeMillis();

        public void run() {
            try {
                while (true) {
                    long t = System.currentTimeMillis() - startTime;
                    System.out.println(t / 1000 + "." + t%1000);
                    Thread.sleep(1000);
                }
            } catch (Exception ex) {

            }
        }
    }

    public static void main(String[] args) {
        WorkThread workThread = new WorkThread();
        PrintThread printThread = new PrintThread();
        workThread.start();
        printThread.start();

    }
}

垃圾回收的并行与并发

并发

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

并行

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

并行与并发的对比

并发，指的是多个事情，在同一时间段内同时发生。并行，指的是多个事情，在同一时间点上同时发生。
并发的多个任务之间是互相抢占资源的，并行的多个任务之间是不相互抢占资源的。
只有在需许多CPU或者一个CPU多核心的情况下，才可能发生并行。否则，看似同时发生的事情，其实都是并发执行的。

垃圾回收的并行与并发

并行与并发，在谈论垃圾收集器的上下文语境中，它们可以解释如下：

并行指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态。如ParNew， Parallel Scavenge，Parallel Old。
串行，相较于并行的概念，单线程执行。如果内存不够，则程序暂停。启动JVM垃圾回收器进行垃圾回收。回收完成再启动用户线程。如：Serial和Serial Old垃圾回收器。
并发指用户线程与垃圾收集线程同时执行（但并不是并行的，可能会交替执行），垃圾收集线程在执行时不会停顿用户程序的运行。如G1，CMS。

引用

我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存中；如果内存空间在进行垃圾收集后还是很紧张，则可以抛弃这些对象。

强引用，软引用、弱引用、虚引用有什么区别？具体适用场景是什么？

在JDK 1.2版本之后，Java对引用的概念进行了扩充，将引用分为强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）4种，这4种引用强度依次逐渐减弱。

除强引用外，其他3种引用均可在java.lang.ref包中找到它们的身影。

Reference子类中只有终结器引用是包内可见的，其他3种引用类型均为public，可以在应用程序种直接使用。

强引用（99%的场景下，都是强引用）

最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj = new Object()”这种引用关系。无论在任何情况下，只要强引用关系还存在，垃圾回收器就永远不会回收掉被引用的对象。

当在Java语言中使用new操作符创建一个新的对象，并将其赋值给一个变量的时候，这个变量就成为指向该对象的一个强引用。

强引用的对象是可触及的，垃圾收集器就永远不会回收掉被引用的对象。

对于一个普通的对象，如果没有其他的引用关系，只要超过了引用的作用域或者显式地将响应的强引用赋值为null，就是可以当作垃圾被收集了。当然具体回收时机还是要看垃圾回收策略。

相对的，软引用、弱引用和虚引用的对象是软可触及、弱可触及和虚可触及的，在一定条件下都是可以被回收的。所以，强引用是造成Java内存泄漏的主要原因之一。

代码：

public class StrongReferenceTest {

    public static void main(String[] args) {
        
        StringBuffer str = new StringBuffer("Hello world");
        StringBuffer str1 = str;

        System.gc();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

软引用（主要用于缓存）

在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收还是没有足够的内存，才会抛出内存溢出异常。

软引用是用来描述一些还有用，但非必须的对象。

软引用通常用来实现内存敏感的缓存。比如：高速缓存就有用到软引用。如果还有空闲内存，就可以暂时保留缓存，当内存不足时清理掉，这样就保证了使用缓存的同时，不会耗尽内存。

垃圾回收器在某个时刻决定回收软引用可达对象的时候，会清理软引用，并可选地把引用存放到一个引用队列。

类似弱引用，只不过Java虚拟机尽量让软引用的存活时间长一些，迫不得已才清理。

代码：

public class SoftReferenceTest {

    public static void main(String[] args) {
        
        Object obj = new Object();

        SoftReference<Object> sf = new SoftReference<>(obj); // 创建软引用
        
        obj = null; // 销毁强引用
    }
}

代码2：

public class SoftReferenceTest2 {

    public static class User {

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        private int id;
        private String name;

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {

        SoftReference<User> userSoftReference = new SoftReference<>(new User(1, "Hobe"));
        System.out.println(userSoftReference.get());

        System.gc();
        System.out.println(userSoftReference.get());

        // 这里设置一下-Xmx10m -Xms10m
        try {
            byte[] b = new byte[7 * 1024 * 1024];
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(userSoftReference.get());
        }
    }
}

输出结果：
User{id=1, name=‘Hobe’}
User{id=1, name=‘Hobe’}
java.lang.OutOfMemoryError: Java heap space
at SoftReferenceTest2.main(SoftReferenceTest2.java:34)
null

从输出的结果，我们可以看出，在发生OOM之前，软引用指向的对象被回收了。这里要注意：在将要发生OOM时，垃圾收集器会回收软引用指向的对象，但是，如软引用指向的对象被回收后，腾出的空间足够容纳新创建的对象，就不会发生OOM；否则就会OOM。

弱引用（主要用于缓存）

被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉弱引用关联的对象。

弱引用也是用来描述那些非必要对象。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。

但是由于垃圾回收器的线程通常优先级很低，因此，并不一定能很快地发现持有弱引用的对象。在这种情况下，弱引用的对象可以存在较长的时间。

弱引用和软引用一样，在构造弱引用时，也可以指定一个引用队列，当弱引用对象被回收时，就会加入指定的引用队列，通过这个队列可以跟踪对象的回收情况。

软引用、弱引用都非常时候来保存那些可有可无的缓存数据。如果这么做，当系统内存不足时，这些缓存数据会被回收，不会导致内存溢出。而当内存资源充足时，这些缓存数据又可以存在相当长的时间，从而起到加速系统的作用。

代码：

import java.lang.ref.WeakReference;

public class WeakReferenceTest {

    public static class User {

        public User(int id, String name) {
            this.id = id;
            this.name = name;
        }

        private int id;
        private String name;

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {

        WeakReference<SoftReferenceTest2.User> userSoftReference = new WeakReference<>(new SoftReferenceTest2.User(1, "Hobe"));
        System.out.println(userSoftReference.get());

        System.gc();
        System.out.println(userSoftReference.get());
    }
}