JVM学习笔记Ⅷ

最新推荐文章于 2024-06-19 16:38:02 发布
最新推荐文章于 2024-06-19 16:38:02 发布
阅读量83 收藏
点赞数
分类专栏： JVM专栏 文章标签： jvm 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MeiMing_104/article/details/128121030
版权

文章目录

16 内存回收相关概念

System.gc()的理解

  • 在默认情况下，通过System.gc()或者Runtime.getRuntime().gc()的调用，会显式触发Full GC，同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。
  • 然而System.gc()调用来决定JVM的GC行为。而一般情况下，垃圾回收应该是自动进行的，无须手动触发，否则就太过于麻烦了。在一些特殊情况下，如我们正在编写一个性能基准，我们可以在运行之间调用System.gc()。
public class SystemGCTest {
    public static void main(String[] args) {
        new SystemGCTest();
        System.gc();  //提醒jvm的垃圾回收器执行gc，但是不确定是否马上执行gc
        /**
         * public static void gc() {
         *     Runtime.getRuntime().gc();
         * }
         */
        System.runFinalization();  // 强制调用使用引用的对象的finalize()方法
    }

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

package com.ming.java;

/**
 * @Author: mei_ming
 * @DateTime: 2022/12/3 11:55
 * @Description:
 * 测试GC情况：
 * -XX:+PrintGCDetails
 */
public class LocalVarGC {
    public void localvarGC1(){
        byte[] buffer = new byte[10*1024*1024];  //10M
        System.gc();
        /**
         * [GC (System.gc()) [PSYoungGen: 12221K->776K(18944K)] 12221K->11024K(62976K), 0.0086821 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
         * [Full GC (System.gc()) [PSYoungGen: 776K->0K(18944K)] [ParOldGen: 10248K->10890K(44032K)] 11024K->10890K(62976K), [Metaspace: 3441K->3441K(1056768K)], 0.0045118 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]
         *
         * 不会回收buffer指向的区域
         */
    }

    public void localvarGC2(){
        byte[] buffer = new byte[10*1024*1024];
        buffer = null;
        System.gc();
        /**
         * [GC (System.gc()) [PSYoungGen: 12221K->696K(18944K)] 12221K->704K(62976K), 0.0019733 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
         * [Full GC (System.gc()) [PSYoungGen: 696K->0K(18944K)] [ParOldGen: 8K->650K(44032K)] 704K->650K(62976K), [Metaspace: 3441K->3441K(1056768K)], 0.0083209 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
         *
         * 会回收buffer指向的区域
         */
    }

    public void localvarGC3(){
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        System.gc();
        /**
         * [GC (System.gc()) [PSYoungGen: 12221K->792K(18944K)] 12221K->11040K(62976K), 0.0101102 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
         * [Full GC (System.gc()) [PSYoungGen: 792K->0K(18944K)] [ParOldGen: 10248K->10890K(44032K)] 11040K->10890K(62976K), [Metaspace: 3441K->3441K(1056768K)], 0.0054530 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
         *
         * 不会回收，因为buffer作用域结束了，但是没人占用他的槽，它还在槽内。
         *   即还没有新数据对他进行覆盖
         */
    }

    public void localvarGC4(){
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        int value = 10;
        System.gc();
        /**
         * [GC (System.gc()) [PSYoungGen: 12221K->776K(18944K)] 12221K->784K(62976K), 0.0140875 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
         * [Full GC (System.gc()) [PSYoungGen: 776K->0K(18944K)] [ParOldGen: 8K->650K(44032K)] 784K->650K(62976K), [Metaspace: 3441K->3441K(1056768K)], 0.0047427 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
         *
         * 此时buffer的槽被value占用了，所以buffer会被回收
         */
    }

    public void localvarGC5(){
        localvarGC1();
        System.gc();
        /**
         * [GC (System.gc()) [PSYoungGen: 12221K->776K(18944K)] 12221K->11024K(62976K), 0.0108282 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
         * [Full GC (System.gc()) [PSYoungGen: 776K->0K(18944K)] [ParOldGen: 10248K->10890K(44032K)] 11024K->10890K(62976K), [Metaspace: 3441K->3441K(1056768K)], 0.0060035 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
         * [GC (System.gc()) [PSYoungGen: 0K->0K(18944K)] 10890K->10890K(62976K), 0.0004488 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
         * [Full GC (System.gc()) [PSYoungGen: 0K->0K(18944K)] [ParOldGen: 10890K->650K(44032K)] 10890K->650K(62976K), [Metaspace: 3442K->3442K(1056768K)], 0.0056938 secs] [Times: user=0.03 sys=0.00, real=0.01 secs]
         *
         * 此时localvarGC1()中的buffer已经被回收
         */
    }

    public static void main(String[] args) {
        LocalVarGC local = new LocalVarGC();
        local.localvarGC5();  //分别调用不同的方法
    }
}

内存溢出与内存泄露

内存溢出

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

先说没有空闲内存的情况：说明Java虚拟机的堆内存不够，原因有2点：

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

这里面隐含着一层意思是，在抛出OuOfMemoryError之前，通常垃圾收集器会被触发，尽其所能去清理出空间。

  • 例如：在引用机制分析中，涉及到JVM会尝试回收软引用指向的对象等。
  • 在java.nio.bits.reserveMemory()方法中，我们能清除的看到，System.gc()会被调用，以便清理空间。

当然，也不是任何情况下垃圾收集器都会被触发的。

  • 比如：我们去分配一个超大对象，类似一个超大数组，超过堆的最大值，JVM可以判断出垃圾收集并不能解决这个问题，所以直接抛OOM。

内存泄露

也称作“存储渗漏”。严格来说，只有对象不会在被程序用到了，但是GC又不能回收它们的情况，才叫内存泄露。
但实际情况很多时候一些不太友好的实践（或疏忽）会导致对象的生命周期变得很长，甚至导致OOM，也可以叫做宽泛意义上的“内存泄露”。
尽管内存泄露并不会立刻引起程序崩溃，但是一旦发生内存泄露，程序中的可用内存就会逐步蚕食，直到耗尽所有内存，最终出现OutOfMemory异常，导致程序崩溃。
注意，这里的存储空间并不是指屋内内存，而是指虚拟内存大小，这个虚拟内存大小取决于磁盘交换区设定的大小。

图示：
内存泄露

举例：

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

Stop The World

  • Stop-the-World, 简称STW，指的是GC事件发生过程中，会产生应用程序停顿。停顿产生时候整个应用程序线程都会被暂停，没有任何响应，有点像卡死的感觉，这个停顿为STW。

  • 可达性分析算法中枚举根节点（GC Roots）会导致所有Java执行线程停顿。

    • 分析工作必须在一个能确保一致性的快照中进行
    • 一致性指整个分析期间整个执行系统看起来像冻结在某个时间点上
    • 如果出现分析过程中对象引用关系还在不断变化，则分析结果的准确性无法保证

  • 被STW中断的应用程序线程会在完成GC之后恢复，频繁中断会让用户感觉像是网速不快造成电影卡带一样，所以我们需要减少STW的发生。

  • STW事件和采用哪款GC无关，所有的GC都有这个事件。

  • 哪怕是G1也不能完全避免Stop-the-world情况发生，只能说垃圾回收器越来越优秀，回收效率越来越高，尽可能地缩短了暂停时间。

  • STW是JVM在后台自动发起和完成的。在用户不可见的情况下，把用户正常的工作线程全部停掉。

  • 开发中不要用System.gc();会导致STW的发生。

package com.ming.java;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author: mei_ming
 * @DateTime: 2022/12/3 15:44
 * @Description: 证明stw的存在
 */
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();
                    }
                }
            }catch (Exception e){
                e.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 e){
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        PrintThread printThread = new PrintThread();
        WorkThread workThread = new WorkThread();
        workThread.start();
        printThread.start();
    }
}

垃圾回收的并行与并发

并发

在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理器上运行。

并发不是真正意义上的“同时进行”，只是CPU把一个时间段划分成几个时间片段（时间区间），然后在这几个时间区间之间来回切换，由于CPU处理的速度非常快，只要时间间隔处理得当，即可让用户感觉是多个应用程序同时在进行。

并发

并行

当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，我们称之为并行（Parallel）。

其实决定并行的因素不是CPU的数量，而是CPU的核心数量，比如一个CPU多个核也可以并行。

适合科学计算，后台处理等弱交互场景
并行

并发和并行对比

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

垃圾回收的并行与并发

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

  • 并行（Parallel）：指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态。

    • 如ParNew、Parallel Scavenge、Parallel old；

  • 串行（Serial）：

    • 相较于并行的概念，单线程执行。
    • 如果内存不够，则程序暂停，启动JM垃圾回收器进行垃圾回收。回收完，再启动程序的线程。

对比

  • 并发（Concurrent）：指用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），垃圾回收线程在执行时不会停顿用户程序的运行。
    • 用户程序在继续运行，而垃圾收集程序线程运行于另一个CPU上；
    • 如：CMS、G1

并发

安全点与安全区域

安全点

程序执行时并非在所有地方都能停顿下来开始GC，只有在特定的位置才能停顿下来开始GC，这些位置称为“安全点（Safepoint）”。

Safe Point的选择很重要，如果太少可能导致GC等待的时间太长，如果太频繁可能导致运行时的性能问题。大部分指令的执行时间都非常短暂，通常会根据“是否具有让程序长时间执行的特征”为标准。
比如：选择一些执行时间较长的指令作为Safe Point，如方法调用、循环跳转和异常跳转等。

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

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

安全区域

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

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

执行流程：

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

强引用

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

【既偏门又非常高频的面试题】强引用、软引用、弱引用、虚引用有什么区别？具体使用场景是什么？
在JDK1.2版之后，Java对引用的概念进行了扩充，将引用分为：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）这4种引用强度依次逐渐减弱。
除强引用外，其他3种引用均可以在java.lang.ref包中找到它们的身影。如下图，显示了这3种引用类型对应的类，开发人员可以在应用程序中直接使用它们。

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

  • 强引用（StrongReference）：最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似Object obj=new Object()这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。（死也不回收）
  • 软引用（SoftReference）：在系统将要发生内存溢出之前，将会把这些对象列入回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存流出异常。（内存不足时回收）
  • 弱引用（WeakReference）：被弱引用关联的对象只能生存到下一次垃圾收集之前。当垃圾收集器工作时，无论内存空间是否足够，都会回收掉被弱引用关联的对象。（发生GC就回收）
  • 虚引用（PhantomReference）：一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来获得一个对象的实例。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。

强引用：-不回收
在Java程序中，最常见的引用类型是强引用（普通系统99%以上都是强引用），也就是我们最常见的普通对象引用，也是默认的引用类型。

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

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

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

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

强引用的案例说明：

package com.ming.java1;

/**
 * @Author: mei_ming
 * @DateTime: 2022/12/3 17:57
 * @Description: 强引用测试
 */
public class StrongReferenceTest {
    public static void main(String[] args) {
        StringBuffer str = new StringBuffer("hi,ming");
        StringBuffer str1 = sb;
        str = null;

        System.gc();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(str);  // null
        System.out.println(str1);  // 能打印出来说明没有回收
    }
}

如上代码：
StringBuffer str = new StringBuffer("hi,ming");
局部变量str指向stringBuffer实例所在堆空间，通过str可以操作该实例，那么str就是StringBuffer实例的强引用对应内存结构：
tu1
如果此时，在运行一个赋值语句
StringBuffer str1 = str;

对应的内存结构为:

tu2

那么我们将 str = null; 则原来堆中的对象也不会被回收，因为还有其它对象指向该区域

总结
本例中的两个引用，都是强引用，强引用具备以下特点：

  • 强引用可以直接访问目标对象。
  • 强引用所指向的对象在任何时候都不会被系统回收，虚拟机宁愿抛出OOM异常，也不会回收强引用所指向对象。
  • 强引用可能导致内存泄漏。

软引用

内存不足即回收。

  • 软引用是用来描述一些还有用，但非必需的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。

注意，这里的第一次回收是不可达的对象

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

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

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

一句话概括：当内存足够时，不会回收软引用可达的对象。内存不够时，会回收软引用的可达对象

  • 在JDK1.2版本之后，提供了SoftReference类来实现软引用
// 声明强引用
Object obj = new Object();
// 创建一个软引用
SoftReference<Object> sf = new SoftReference<>(obj);
obj = null; //销毁强引用，这是必须的，不然会存在强引用和软引用

代码举例：

package com.ming.java1;

import java.lang.ref.SoftReference;

/**
 * @Author: mei_ming
 * @DateTime: 2022/12/3 19:46
 * @Description: 软引用测试：内存满时回收，不一定要报OOM时回收。
 * -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 "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

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

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

        System.gc();
        System.out.println("After GC:");
        // 垃圾回收之后，获得软引用中的对象
        System.out.println(softReference.get());// 由于堆空间内存足够，所以不会回收软引用的可达对象

        try{
            //让系统认为内存资源紧张，不够
            //内存不够
//            byte[] b = new byte[1024*1024*7];
            //内存资源紧张
            byte[] b = new byte[1024*7168-646*1024];
        }catch (Throwable e){
            e.printStackTrace();
        }finally {
            // 再次从软引用中获取数据
            System.out.println(softReference.get());  // 在报OOM之前，垃圾回收器会回收软引用的可达对象
        }

        /**
         * 内存不够时： byte[] b = new byte[1024*1024*7];
         * User{id=1, name='mem'}
         * After GC:
         * User{id=1, name='mem'}
         * java.lang.OutOfMemoryError: Java heap space
         * 	at com.ming.java1.SoftReferenceTest.main(SoftReferenceTest.java:47)
         * null
         *
         * 内存资源紧张: byte[] b = new byte[1024*7168-646*1024];
         * User{id=1, name='mem'}
         * After GC:
         * User{id=1, name='mem'}
         * null
         *  
         */

    }
}

弱引用

发现即回收

弱引用也是用来描述那些非必需对象，只被弱引用关联的对象只能生存到下一次垃圾收集发生为止。在系统GC时，只要发现弱引用，不管系统堆空间使用是否充足，都会回收掉只被弱引用关联的对象。

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

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

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

在JDK1.2版之后提供了WeakReference类来实现弱引用

// 声明强引用
Object obj = new Object();
// 创建一个弱引用
WeakReference<Object> wr = new WeakReference<>(obj);
obj = null; //销毁强引用，这是必须的，不然会存在强引用和弱引用

弱引用对象与软引用对象的最大不同就在于，当GC在进行回收时，需要通过算法检查是否回收软引用对象，而对于弱引用对象，GC总是进行回收。弱引用对象更容易、更快被GC回收。

面试题：你开发中使用过WeakHashMap吗？
WeakHashMap用来存储图片信息，可以在内存不足的时候，及时回收，避免了OOM

代码举例：

package com.ming.java1;

import java.lang.ref.WeakReference;

/**
 * @Author: mei_ming
 * @DateTime: 2022/12/3 21:17
 * @Description: 弱引用 - 测试
 */
public class WeakReferenceTest {
    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 "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) {
        // 构造弱引用
        WeakReference<User> weakReference = new WeakReference<User>(new User(1, "mem"));
        //从弱引用中重新获取对象
        System.out.println(weakReference.get());

        System.gc();
        // 不管当前内存空间足够与否，都会回收他的内存
        System.out.println("After GC:");
        // 重新尝试从弱引用中获取对象
        System.out.println(weakReference.get());
        /**
         * User{id=1, name='mem'}
         * After GC:
         * null
         */
    }
}

虚引用

对象回收跟踪

  • 也称为“幽灵引用”或者“幻影引用”，是所有引用类型中最弱的一个

  • 一个对象是否有虚引用的存在，完全不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它和没有引用几乎是一样的，随时都可能被垃圾回收器回收。

  • 它不能单独使用，也无法通过虚引用来获取被引用的对象。当试图通过虚引用的get()方法取得对象时，总是null

  • 为一个对象设置虚引用关联的唯一目的在于跟踪垃圾回收过程。比如：能在这个对象被收集器回收时收到一个系统通知。

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

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

  • 在JDK1.2版之后提供了PhantomReference类来实现虚引用。

Object obj = new Object();
ReferenceQueue phantomQueue = new ReferenceQueue();
PhantomReference<Object> pf = new PhantomReference<>(obj,phantomQueue);
obj = null; //销毁强引用，这是必须的，不然会存在强引用和弱引用

代码说明：

package com.ming.java1;

import javax.print.attribute.standard.RequestingUserName;
import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

/**
 * @Author: mei_ming
 * @DateTime: 2022/12/3 21:29
 * @Description: 虚引用 - 测试
 */
public class PhantomReferenceTest {
    public static PhantomReferenceTest obj;  // 当前类对象的声明
    static ReferenceQueue<PhantomReferenceTest> phantomQueue = null;  // 引用队列

    @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> phantomReference = new PhantomReference<PhantomReferenceTest>(obj,phantomQueue);
        try{
            // 不可获取虚引用中的对象
            System.out.println(phantomReference.get());  // null

            //将强引用去除
            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();  // 当这个gc调用时，对象无法复活，一旦obj对象被回收，就会将此虚引用存放到引用队列里
            Thread.sleep(1000);
            if (obj == null){
                System.out.println("obj 是 null");
            }else{
                System.out.println("obj 可用");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private 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了");
                    }
                }
            }
        }
    }
}

终结器引用

  • 它用于实现对象的finalize() 方法，也可以称为终结器引用

  • 无需手动编码，其内部配合引用队列使用

  • 在GC时，终结器引用入队。由Finalizer线程通过终结器引用找到被引用对象调用它的finalize()方法，第二次GC时才回收被引用的对象

MeiMing_104
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马JVM学习笔记二
01-20
title: 黑马JVM学习笔记二 date: 2020-01-13 1:00:00 tags: JVM categories: JVM 黑马jvm 内存结构 内存结构总览图： 程序计数器 1.定义：Program Counter Register 程序计数器 (寄存器) 程序计数器是Java对物理...
JVM学习笔记
04-28
从JVM内存模型、常用JVM参数、垃圾回收算法和垃圾回收器等几个角度学习JVM
Java学习笔记
m0_62122789的博客
09-06 738
目录名称说明bin该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。conf该路径下存放了JDK的相关配置文件。include该路径下存放了一些平台特定的头文件。jmods该路径下存放了JDK的各种模块。legal该路径下存放了JDK各模块的授权文档。lib该路径下存放了JDK工具的一些补充JAR包。project（项目、工程）module（模块）package（包）class（类）
Flink学习笔记(1) -- Flink入门介绍
小道的博客
12-31 1045
Flink是一个分布式大数据计算引擎，可对有限流和无限流进行有状态的计算，支持Java API和Scala API、高吞吐量低延迟、支持事件处理和无序处理、支持一次且仅一次的容错担保、支持自动反压机制、兼容Hadoop、Storm、HDFS和YARN。(1) DataSource是指数据处理的数据源，可以是HDFS\Kafka\Hive等；(2) Transformations是指对数据的处理转换的函数方法；
Java笔记_7（字符串）
weixin_74155781的博客
03-29 433
Java_7笔记（字符串）
收藏！2024 年最具潜力 44 个顶级开源项目，涵盖 11 类 AI 学习框架、平台_序列大数据的智能计算 开源项目(3)
afagagagaa的博客
05-04 1176
其中，包含了算法预处理，模型参数择优，回归与分类等算法，官方文档包含了每一种算法的例子，代码简洁优美，可视化了每一种算法结果，即能学习 python，也是帮助开发者更好理解机器学习算法的便利工具。MXNet 提供了混合编程模型（命令式和声明式）和大量编程语言的代码（包括 Python、C++、R、Scala、Julia、Matlab 和 JavaScript）的能力，是一个易安装易上手的开源深度学习工具，它提供了一个 python 接口 gluon，能够让开发者迅速搭建起神经网络，并进行高效训练。
JavaSE阶段笔记
a2582497403的博客
10-20 592
JavaSE 一.Java编程基础 ①.数据类型 基本数据类型 数值型（int，long） 字符型（char） 布尔型（boolean） 引用数据类型 类（class） 接口（interface） 数组 枚举（enum） 注解（Annotation） 英文 音标 汉语 数据类型 integer [ˈɪntɪdʒə®] 整数 数值型 long [lɒŋ] 长的 数值型 char [tʃɑː®] 字符型 class [klɑːs] 类 引用数据类型 interfac
【Java】「深入理解Java虚拟机」学习笔记（4）- 类文件结构
weixin_30790841的博客
11-08 58
　　我为什么喜欢Java，另一个重要原因就是跨平台，WORA。 　　程序员是爽了，但肯定有人要为你遮风挡雨，解决WORA的基石就是字节码+虚拟机。　　　 ♣Tip 　　其实这里存在两种无关性，一是平台无关性、另一个是语言无关性。通过向不同的硬件平台和操作系统提供 不同的JVM实现上层应用和底层平台之间的解耦；另一个，JVM生态系统中有多种语言如Scala、Groovy和Jr...
Java学习笔记===》8.面向对象进阶1
m0_59318477的博客
05-31 260
​ ★继承是面向对象三大特征之一，可以让类跟类之间产生父子的关系​ ★把多个子类中重复的代码抽取到父类中，子类可以直接使用，减少代码冗余，提高复用性★this：理解为一个变量，表示当前方法调用者的地址值s . show();//可以把对象在内存中的结构打印出来 ClassLayout layout = ClassLayout . parseInstance(s);} }int age;
收藏！2020 年最具潜力 44 个顶级开源项目，涵盖 11 类 AI 学习框架、平台
王博（Kings）的博客
02-23 8728
工欲善其事必先利其器，这也是大部分开发者在日常工作中最重要开发原则。选择与开发内容相匹配的工具，常常会使我们事半功倍。但面对人工智能的多个领域，如：机器学习、深度学习、NLP等等，多样的工具有时也让我们也无从选择。 就在最近，一个基于 javascript 的可视化库 D3js（treemap 可视化）对 json 文件生成的技术图，给开发者提供了详细的各领域工具清单，内容涵盖了 11 种极具潜...
2020 年最具潜力 44 个顶级开源项目，涵盖 11 类 AI 学习框架、平台（值得收藏）
喜欢打酱油的老鸟
02-12 4159
导语：​Github 开源项目技术图 雷锋网 AI 开发者按：工欲善其事必先利其器，这也是大部分开发者在日常工作中最重要开发原则。选择与开发内容相匹配的工具，常常会使我们事半功倍。但面对人工智能的多个领域，如：机器学习、深度学习、NLP等等，多样的工具有时也让我们也无从选择。 就在最近，一个基于 javascript 的可视化库 D3js（treemap 可视化）对 json 文件生成的技术图...
jvm学习笔记.zip
04-04
jvm经典笔记
JVM学习笔记(一)
06-02
一份JVM学习的笔记,含查看JVM运行时信息\JVM垃圾收集信息\JVM锁信息等
jVM学习笔记.ppt
11-20
jVM学习笔记.ppt
JVM 性能分析案列——使用 JProfiler 工具分析 dump.hprof 堆内存快照文件排查内存溢出问题
longool的博客
06-15 540
在 windows 环境下实现。
【Java面试】二十一、JVM篇（中）：垃圾回收相关
最新发布
llg___的博客
06-19 572
JVM处理class字节码文件成为二进制文件，类加载的作用则是将class字节码文件加载到JVM中。启动类加载器：加载JDK下的jre/lib下的类，这个加载器由C++实现扩展类加载器：加载JDK下的jre/lib/ext下的类，如果把开发者自己写的class放这个目录，也会被扩展类加载器加载应用类加载器：加载开发者自己写的class自定义类加载器：自己去继承ClassLoader，自己实现。
[图解]企业应用架构模式2024新译本讲解14-服务层2
rolt的专栏
06-19 289
那么这个就跳到DbManager这里了
【JVM】详解Java 堆内存分区
hui_zai_的博客
06-13 1031
Java 堆内存分区
宋红康jvm学习笔记 逃逸分析
05-19
逃逸分析是JVM在运行时对对象的分析，用于确定对象的作用域。如果对象只在方法内部使用，那么它就不会逃逸出该方法，否则就会逃逸。逃逸分析可以优化程序的性能，因为当对象不逃逸时，JVM可以将它们放在线程栈上分配...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值