内存与垃圾回收篇--16 垃圾回收相关概念 -B站尚硅谷JVM课程学习

进阶中的程序猿

已于 2022-03-17 11:18:26 修改

阅读量252

点赞数

分类专栏： JVM 文章标签：学习 java 开发语言

于 2022-03-15 20:22:29 首次发布

本文链接：https://blog.csdn.net/x18845040365/article/details/123507457

版权

JVM 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

System.gc的理解

与Runtime.getRuntime().gc()调用一样
会触发显示 Full GC
提醒jvm的垃圾回收新给，但无法保证对垃圾收集器的调用
垃圾回收是自动进行的，无须手动调用
调用System.runFinalization 强制调用使用引用的对象的finalize方法

内存溢出与内存泄露

内存溢出（OOM）：Full GC后内存仍然不够用

JVM大的堆内存设置不够
代码中创建了大量对象，并且长时间不能被垃圾回收器收集

内存泄露（Memory Leak）：只有对象不再被程序用到了，但是GC又不能回收他们
宽泛意义上：对象的生命周期变得很长导致OOM

内存泄漏可能会导致OOM

举例：

单例模式：单例程序中持有对外部对象的引用，因为单例的生命周期时间很长
一些提供close的资源未关闭导致内存泄露

Stop the World

在可达性分析算法中，要知道哪些都是GCRoots，由于是变化的，所以需要stop，即要确保数据的一致性
STW和垃圾回收器无关，都会产生STW，要尽可能缩短STW时间
STW是JVM在后台自动发起和自动完成的
System.gc开发中不要用，会触发STW

package chapter16;

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

public class STWDemo {

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

        public void run(){
            while (true){
                for (int i =0; i < 1000; i++){
                    byte[] bytes = new byte[1024];
                    list.add(bytes);
                }
                if (list.size() > 10000){
                    list.clear();
                    System.gc();//导致STW
                }
            }
        }
    }

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

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

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

在这里插入图片描述

垃圾回收的并行与并发

并发（Concurrent）：多个程序来回切换，看起来是同时在执行（发消息和听歌）
并行（Parallel）：同时执行（CPU几核）

并行垃圾回收器：多条垃圾收集线程并行工作
串行垃圾回收器：单线程执行
在这里插入图片描述

并发垃圾回收器：用户线程和垃圾回收线程同时执行（CMS、G1）
在这里插入图片描述

安全点与安全区域

安全点：safepoint 特定位置停下来进行GC

安全点太少可能会导致GC等待时间过长，可能导致OOM；太频繁会导致运行时性能问题
选择一些执行时间较长的指令作为SafePoint，如方法调用、循环跳转和异常跳转等

如何在GC发生时，检查所有线程都跑到最近的安全点停顿下来呢？

抢先试中断：中断所有线程，如果还有线程不在安全点，就恢复线程，让线程跑到安全点（已经不用了）
主动式中断：设置一个中断标志，各个线程运行到安全点时主动轮训这个标志，如果为真，则将自己中断挂起

安全区域：代码片段中，对象的引用关系不会发生变化，这个区域中任何位置开始GC都是安全的

实际执行时：

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

再谈引用：强引用（Strong Reference）

内存紧张，抛弃一些对象（相当于缓存）
在这里插入图片描述
Object object = new Object();强引用
无论任何情况下，只要强引用还在，垃圾回收器永远不会回收被引用的对象，永远是可触及的
造成内存泄露的主要原因

再谈引用：软引用（Soft Reference）

内存溢出之前，可以回收软引用，如果回收后仍然没有足够空间，则OOM
缓存类似软引用
当内存足够时，不会回收软引用的可达对象。内存不够时，回收

package chapter16;

import java.lang.ref.SoftReference;

class User{
    private int id;
    private String name;

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

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

public class SoftReferenceTest {

    public static void main(String[] args) {

//        SoftReference<User> xinxue = new SoftReference<>(new User(1, "xinxue"));//软引用

//       上面一行代码等价于下面三行代码

        User xinxue1 = new User(1, "xinxue");
        SoftReference<User> userSoftReference = new SoftReference<>(xinxue1);
        xinxue1 = null;

        System.out.println(userSoftReference.get());
        System.gc();
        System.out.println("After GC ..");
//        垃圾回收后获得软引用的对象
        System.out.println(userSoftReference.get());

        try{
//            让系统认为内存紧张
            byte[] bytes = new byte[1024 * 1024 * 7];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
//            再次从软引用中获取数据
            System.out.println(userSoftReference.get());
        }

    }
}

"C:\Program Files\Java\jdk1.8.0_181\bin\java.exe" -Xms10m -Xmx10m -XX:+PrintGCDetails "-javaagent:E:\idea-pro\IntelliJ IDEA 2021.1.3\lib\idea_rt.jar=54325:E:\idea-pro\IntelliJ IDEA 2021.1.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_181\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_181\jre\lib\rt.jar;E:\TestJVM\target\classes" chapter16.SoftReferenceTest
User{id=1, name='xinxue'}
[GC (System.gc()) [PSYoungGen: 1943K->488K(2560K)] 1943K->692K(9728K), 0.0441455 secs] [Times: user=0.00 sys=0.00, real=0.06 secs] 
[Full GC (System.gc()) [PSYoungGen: 488K->0K(2560K)] [ParOldGen: 204K->653K(7168K)] 692K->653K(9728K), [Metaspace: 3444K->3444K(1056768K)], 0.0285364 secs] [Times: user=0.03 sys=0.00, real=0.03 secs] 
**After GC ..
User{id=1, name='xinxue'}**
[GC (Allocation Failure) [PSYoungGen: 37K->32K(2560K)] 690K->685K(9728K), 0.0013786 secs] [Times: user=0.02 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 32K->32K(2560K)] 685K->685K(9728K), 0.0009643 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 32K->0K(2560K)] [ParOldGen: 653K->649K(7168K)] 685K->649K(9728K), [Metaspace: 3445K->3445K(1056768K)], 0.0143615 secs] [Times: user=0.00 sys=0.00, real=0.01 secs] 
[GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] 649K->649K(9728K), 0.0012494 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (Allocation Failure) [PSYoungGen: 0K->0K(2560K)] [ParOldGen: 649K->631K(7168K)] 649K->631K(9728K), [Metaspace: 3445K->3445K(1056768K)], 0.0305588 secs] [Times: user=0.11 sys=0.00, real=0.03 secs] 
**null**
Heap
 PSYoungGen      total 2560K, used 119K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 5% used [0x00000000ffd00000,0x00000000ffd1de58,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
  to   space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
 ParOldGen       total 7168K, used 631K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 8% used [0x00000000ff600000,0x00000000ff69dd18,0x00000000ffd00000)
 Metaspace       used 3476K, capacity 4500K, committed 4864K, reserved 1056768K
  class space    used 379K, capacity 388K, committed 512K, reserved 1048576K
java.lang.OutOfMemoryError: Java heap space
	at chapter16.SoftReferenceTest.main(SoftReferenceTest.java:41)

Process finished with exit code 0

再谈引用：弱引用（Weak Reference）

只要垃圾收集器工作，都回收弱引用

package chapter16;

import java.lang.ref.WeakReference;


public class WeakReferenceTest {

    public static void main(String[] args) {

//        WeakReference<User> xinxue = new WeakReference<>(new User(1, "xinxue"));//软引用

//       上面一行代码等价于下面三行代码

        User xinxue1 = new User(1, "xinxue");
        WeakReference<User> userWeakReference = new WeakReference<User>(xinxue1);
        xinxue1 = null;

        System.out.println(userWeakReference.get());
        System.gc();
        System.out.println("After GC ..");
//        垃圾回收后获得软引用的对象
        System.out.println(userWeakReference.get());


    }
}

在这里插入图片描述

再谈引用：虚引用（Phantom Reference）

在这个对象被收集器回收时会受到系统通知，对象回收跟踪
创建时必须要提供一个引用队列作为参数

package chapter16;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;



public class PhantomReferenceTest {
    public static PhantomReferenceTest obj;
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null;

    public static class CheckQueue extends Thread{
        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了");
                    }
                }
            }
        }
    }

    /**
     * 只能被调用一次
     * @throws Throwable
     */
    public void finalize() throws Throwable{
        super.finalize();
        System.out.println("调用当前类的finalize方法。。。");
        obj = this;//对象复活
    }

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

        phantomQueue = new ReferenceQueue<>();
        obj = new PhantomReferenceTest();

        PhantomReference<PhantomReferenceTest> phantomRef = new PhantomReference<>(obj, phantomQueue);

        try {
            System.out.println(phantomRef.get());
            obj = null;
            System.gc();
            Thread.sleep(1000);
            if (obj == null){
                System.out.println("obj is  null");
            } else {
                System.out.println("obj 可用");
            }
            System.out.println("第二次 GC");
            obj = null;
            System.gc();//一旦将obj对象回收，就会将此虚引用放到队列中了
            if (obj == null){
                System.out.println("obj is  null");
            } else {
                System.out.println("obj 可用");
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

再谈引用：终结器引用

实现对象的finalize方法，GC时也会进入引用队列

进阶中的程序猿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
内存与垃圾回收篇--16 垃圾回收相关概念 -B站尚硅谷JVM课程学习

System.gc的理解与Runtime.getRuntime().gc()调用一样会触发显示 Full GC提醒jvm的垃圾回收新给，但无法保证对垃圾收集器的调用垃圾回收是自动进行的，无须手动调用调用System.runFinalization 强制调用使用引用的对象的finalize方法内存溢出与内存泄露内存溢出（OOM）：Full GC后内存仍然不够用JVM大的堆内存设置不够代码中创建了大量对象，并且长时间不能被垃圾回收器收集内存泄露（Memory Leak）：只有对象不再
复制链接

扫一扫