JVM11_System.gc、内存溢出、内存泄漏、STW、安全点、安全区域、强软弱虚引用

已于 2022-03-10 21:42:19 修改
阅读量2.1k 收藏 2
点赞数 8
分类专栏： JVM虚拟机 文章标签： jvm
于 2020-09-07 09:48:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TZ845195485/article/details/108441337
版权

文章目录

①. System.gc()的理解

  • ①. 在默认情况下,通过System.gc( )或者Runtime.getRuntime( ).gc( )的调用,会显式触发Full GC,同时对老年代和新生代进行回收,尝试释放被丢弃对象占用的内存。

  • ②. 然而System.gc()调用附带一个免责声明,无法保证对垃圾收集器的调用(无法保证马上触发GC)。
    (不保证一定会发生垃圾收集,只是给jvm发出提示)

  • ③. JVM实现者可以通过system.gc( )调用来决定JVM的GC行为。而一般情况下,垃圾回收应该是自动进行的,无须手动触发,否则就太过于麻烦了。在一些特殊情况下,如我们正在编写一个性能基准,我们可以在运行之间调用System.gc( )

  • ④. 以下代码,如果注掉System.runFinalization( ); 那么控制台不保证一定打印,证明了System.gc( )无法保证GC一定执行

public class SystemGCTest {
    public static void main(String[] args) {
        new SystemGCTest();
        System.gc();//提醒jvm的垃圾回收器执行gc,但是不确定是否马上执行gc
        //与Runtime.getRuntime().gc();的作用一样。
        System.runFinalization();//强制调用使用引用的对象的finalize()方法
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("SystemGCTest 重写了finalize()");
    }
}
  • ⑤. 手动gc理解不可达对象的回收行为
public class LocalVarGC {
    public void localvarGC1() {
        byte[] buffer = new byte[10 * 1024 * 1024];//10MB
        System.gc();
        //输出: 不会被回收, FullGC时被放入老年代
        //[GC (System.gc()) [PSYoungGen: 14174K->10736K(76288K)] 14174K->10788K(251392K), 0.0089741 secs] [Times: user=0.01 sys=0.00, real=0.01 secs]
        //[Full GC (System.gc()) [PSYoungGen: 10736K->0K(76288K)] [ParOldGen: 52K->10649K(175104K)] 10788K->10649K(251392K), [Metaspace: 3253K->3253K(1056768K)], 0.0074098 secs] [Times: user=0.01 sys=0.02, real=0.01 secs]
    }

    public void localvarGC2() {
        byte[] buffer = new byte[10 * 1024 * 1024];
        buffer = null;
        System.gc();
        //输出: 正常被回收
        //[GC (System.gc()) [PSYoungGen: 14174K->544K(76288K)] 14174K->552K(251392K), 0.0011742 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
        //[Full GC (System.gc()) [PSYoungGen: 544K->0K(76288K)] [ParOldGen: 8K->410K(175104K)] 552K->410K(251392K), [Metaspace: 3277K->3277K(1056768K)], 0.0054702 secs] [Times: user=0.01 sys=0.00, real=0.01 secs]

    }

    public void localvarGC3() {
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        System.gc();
        //输出: 不会被回收, FullGC时被放入老年代
        //[GC (System.gc()) [PSYoungGen: 14174K->10736K(76288K)] 14174K->10784K(251392K), 0.0076032 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
        //[Full GC (System.gc()) [PSYoungGen: 10736K->0K(76288K)] [ParOldGen: 48K->10649K(175104K)] 10784K->10649K(251392K), [Metaspace: 3252K->3252K(1056768K)], 0.0096328 secs] [Times: user=0.01 sys=0.01, real=0.01 secs]
    }

    public void localvarGC4() {
        {
            byte[] buffer = new byte[10 * 1024 * 1024];
        }
        int value = 10;
        System.gc();
        //输出: 正常被回收
        //[GC (System.gc()) [PSYoungGen: 14174K->496K(76288K)] 14174K->504K(251392K), 0.0016517 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]
        //[Full GC (System.gc()) [PSYoungGen: 496K->0K(76288K)] [ParOldGen: 8K->410K(175104K)] 504K->410K(251392K), [Metaspace: 3279K->3279K(1056768K)], 0.0055183 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
    }

    public void localvarGC5() {
        localvarGC1();
        System.gc();
        //输出: 正常被回收
        //[GC (System.gc()) [PSYoungGen: 14174K->10720K(76288K)] 14174K->10744K(251392K), 0.0121568 secs] [Times: user=0.02 sys=0.00, real=0.02 secs]
        //[Full GC (System.gc()) [PSYoungGen: 10720K->0K(76288K)] [ParOldGen: 24K->10650K(175104K)] 10744K->10650K(251392K), [Metaspace: 3279K->3279K(1056768K)], 0.0101068 secs] [Times: user=0.01 sys=0.02, real=0.01 secs]
        //[GC (System.gc()) [PSYoungGen: 0K->0K(76288K)] 10650K->10650K(251392K), 0.0005717 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]
        //[Full GC (System.gc()) [PSYoungGen: 0K->0K(76288K)] [ParOldGen: 10650K->410K(175104K)] 10650K->410K(251392K), [Metaspace: 3279K->3279K(1056768K)], 0.0045963 secs] [Times: user=0.01 sys=0.00, real=0.00 secs]
    }

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

②. 内存溢出(out of Memory)

  • ①. javadoc中对OutOfMemoryError的解释是,没有空闲内存,并且垃圾收集器也无法提供更多内存

  • ②. 说明Java虚拟机的堆内存不够。原因有二

  1. Java虚拟机的堆内存设置不够(比如:可能存在内存泄漏问题；也很有可能就是堆的大小不合理,比如我们要处理比较可观的数据量,但是没有显式指定JVM堆大小或者指定数值偏小。我们可以通过参数一Xms、一Xmx来调整)
  2. 代码中创建了大量大对象,并且长时间不能被垃圾收集器收集(存在被引用)
  • ③. 这里面隐含着一层意思是,在抛出0utOfMemoryError之前,通常垃圾收集器会被触发,尽其所能去清理出空间。
  1. 例如:在引用机制分析中,涉及到JVM会去尝试回收软引用指向的对象等。
  2. 在java.nio.BIts.reserveMemory()方法中,我们能清楚的看到,System.gc()会被调用,以清理空间。
  • ④. 当然,也不是在任何情况下垃圾收集器都会被触发的(OOM之前会触发GC吗?)
    (比如,我们去分配一一个超大对象,类似一个超大数组超过堆的最大值,JVM可以判断出垃圾收集并不能解决这个问题,所以直接拋出OutOfMemoryError)

③. 内存泄漏(Memory Leak)

  • ①. 也称作“存储渗漏”。严格来说,只有对象不会再被程序用到了,但是GC又不能回收他们的情况,才叫内存泄漏

  • ②. 但实际情况很多时候一些不太好的实践(或疏忽)会导致对象的生命周期变得很长甚至导致OOM,也可以叫做宽泛意义上的“内存泄漏

  • ③. 尽管内存泄漏并不会立刻引起程序崩溃,但是一旦发生内存泄漏,程序中的可用内存就会被逐步蚕食,直至耗尽所有内存,最终出现0utOfMemory异常,导致程序崩溃。

  • ④. Java中内存泄漏的8种情况

  1. 单例模式(单例的生命周期和应用程序是一样长的,所以单例程序中,如果持有对外部对象的引用的话,那么这个外部对象是不能被回收的,则会导致内存泄漏的产生。)
  2. 一些提供close的资源未关闭导致内存泄漏数据库连接( dataSourse. getConnection()),网络连接(socket)和io连接必须手动close,否则是不能被回收的。
  3. 静态集合类(如HashMap、LinkedList等等。如果这些容器为静态的,那么它们的生命周期与JVM程序一致,则容器中的对象在程序结束之前将不能被释放,从而造成内存泄漏。简单而言,长生命周期的对象持有短生命周期对象的引用,尽管短生命周期的对象不再使用,但是因为长生命周期对象持有它的引用而导致不能被回收)
  4. 内部类持有外部类(内部类持有外部类,如果一个外部类的实例对象的方法返回了一个内部类的实例对象。这个内部类对象被长期引用了,即使那个外部类实例对象不再被使用,但由于内部类持有外部类的实例对象,这个外部类对象将不会被垃圾回收,这也会造成内存泄漏。)
  5. 变量不合理的作用域(一般而言,一个变量的定义的作用范围大于其使用范围,很有可能会造成内存泄漏。另一方面,如果没有及时地把对象设置为null,很有可能导致内存泄漏的发生)
  6. 改变哈希值
  7. 缓存泄漏(内存泄漏的另一个常见来源是缓存,一旦你把对象引用放入到缓存中,他就很容易遗忘。比如:之前项目在一次上线的时候,应用启动奇慢直到夯死,就是因为代码中会加载一个表中的数据到缓存(内存)中,测试环境只有几百条数据,但是生产环境有几百万的数据)
  8. 监听器和回调(内存泄漏另一个常见来源是监听器和其他回调,如果客户端在你实现的API中注册回调,却没有显式的取消,那么就会积聚)
//静态集合类
public class MemoryLeak {
    static List list = new ArrayList();

    public void oomTests() {
        Object obj = new Object();//局部变量
        list.add(obj);
    }
}
//变量不合理的作用域
public class UsingRandom {
     private String msg;
     public void receiveMsg(){
        //private String msg;
        readFromNet();// 从网络中接受数据保存到msg中
        saveDB();// 把msg保存到数据库中
        //msg = null;
     }
}
//改变哈希值
public class ChangeHashCode {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        Person p1 = new Person(1001, "AA");
        Person p2 = new Person(1002, "BB");

        set.add(p1);
        set.add(p2);
        p1.name = "CC";
        set.remove(p1);
        System.out.println(set);//2个对象！
        
//        set.add(new Person(1001, "CC"));
//        System.out.println(set);
//        set.add(new Person(1001, "AA"));
//        System.out.println(set);

    }
}

④. Stop The World

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

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

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

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

  • ⑤. 开发中不要用System.gc(),会导致full gc,会导致Stop一the一world的发生

  • ⑥. 什么情况下会导致stop the world 记住

  1. 可达性分析算法中枚举根节点(GC Roots)会导致所有Java执行线程停顿

  2. 进行gc的时候会发生STW现象(调用finalize()方法的时候会暂停用户线程

  3. System.gc( ) | 调用finalize( )方法

⑤. 多线程中的并行与并发

  • ①. 并发(Concurrent)
  1. 在操作系统中,是指一个时间段中有几个程序都处于己启动运行到运行完毕之间,且这几个程序都是在同一个处理器_上运行
  2. 并发不是真正意义上的“同时进行”,只是CPU把一个时间段划分成几个时间片段(时间区间),然后在这几个时间区间之间来回切换,由于CPU处理的速度非常快,只要时间间隔处理得当,即可让用户感觉是多个应用程序同时在进行
  3. 图解:
    在这里插入图片描述
  • ②. 并行(Parallel)
  1. 当系统有一个以上CPU时,当一个CPU执行一个进程时,另一个CPU可以执行另一个进程,两个进程互不抢占CPU资源,可以同时进行,我们称之为并行(Parallel)
  2. 其实决定并行的因素不是CPU的数量,而是CPU的核心数量,比如一个CPU多个核也可以 并行
  3. 图解:
    在这里插入图片描述

⑥. 垃圾回收的并行、串行、并发

  • ①. 并行(Parallel) :指多条垃圾收集线程并行工作,但此时用户线程仍处于等待状态。如ParNew、 Parallel Scavenge、 Parallel 0ld；

  • ②. 串行(Serial)

  1. 相较于并行的概念,单线程执行。
  2. 如果内存不够,则程序暂停,启动JVM垃圾回收器进行垃圾回收。回收完,再启动程序的线程。
  3. 图解:
    在这里插入图片描述
  • ③. 并发
  1. 指用户线程与垃圾收集线程同时执行(但不一定是并行的,可能会交替执行),垃圾回收线程在执行时不会停顿用户程序的运行
  2. 在同一个时间段,用户线程和垃圾回收线程同时执行
  3. 图解
    在这里插入图片描述

⑦. 安全点(Safepoint)

  • ①. 程序执行时并非在所有地方都能停顿下来开始GC,只有在特定的位置才能停顿下来开始GC,这些位置称为"安全点(Safepoint)"

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

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

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

⑧. 安全区域(Safe Region)

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

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

  • ③. 实际执行时:

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

⑨. 引用

  • ①. 我们希望能描述这样一类对象: 当内存空间还足够时,则能保留在内存中；如果内存空间在进行垃圾收集后还是很紧张,则可以抛弃这些对象。 -【既偏门又非常高频的面试题】强引用、软引用、弱引用、虚引用有什么区别？具体使用.场景是什么？

  • ②. 在JDK 1.2版之后,Java对引用的概念进行了扩充,将引用分为强引用(Strong
    Reference)、软引用(Soft Reference) 、弱引用(Weak Reference) 和虚引用(Phantom Reference) 4种,这4种引用强度依次逐渐减弱

  • ③. 除强引用外,其他3种引用均可以在java.lang.ref包中找到它们的身影。如下图,显示了这3种引用类型对应的类,开发人员可以在应用程序中直接使用它们。
    在这里插入图片描述

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

  • ⑤. 简单介绍下强软弱虚引用

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

在这里插入图片描述

①. 强引用:不回收

  • 在Java程序中,最常见的引用类型是强引用(普通系统99%以上都是强引用),也就是我们最常见的普通对象引用,也是默认的引用类型。

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

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

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

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

②. 软引用: 内存不足即回收

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

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

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

  • ④. 软引用:

  1. 当内存足够: 不会回收软用的可达对象
  2. 当内存不够时: 会回收软引用的可达对象
  • ⑤. 在JDK 1. 2版之后提供了java.lang.ref.SoftReference类来实现软引用。
	Object obj = new object()； //声明强引用
	SoftReference<0bject> sf = new SoftReference<0bject>(obj)；
	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 * 7];
            byte[] b = new byte[1024 * 7168 - 399 * 1024];//恰好能放下数组又放不下u1的内存分配大小 不会报OOM
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            //再次从软引用中获取数据
            System.out.println(userSoftRef.get());//在报OOM之前,垃圾回收器会回收软引用的可达对象。
        }
    }
}

③. 弱引用: 发现即回收

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

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

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

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

  • ⑤. 在JDK1.2版之后提后了java.lang.ref.WeakReference类来实现弱引用

	Object obj = new object()； //声明强引用
	WeakReference<0bject> sf = new WeakReference<0bject>(obj)；
	obj = null； //销毁强引用
  • ⑥. 面试题:你开发中使用过WeakHashMap吗？
  1. 通过查看WeakHashMap源码,可以看到其内部类Entry使用的就是弱引用
  2. line 702 -> private static class Entry<K,V> extends WeakReference implements Map.Entry<K,V> {…}
	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 "[id=" + id + ", name=" + name + "] ";
	        }
	    }
	
	    public static void main(String[] args) {
	        //构造了弱引用
	        WeakReference<User> userWeakRef = new WeakReference<User>(new User(1, "songhk"));
	        //从弱引用中重新获取对象
	        System.out.println(userWeakRef.get());
	
	        System.gc();
	        // 不管当前内存空间足够与否,都会回收它的内存
	        System.out.println("After GC:");
	        //重新尝试从弱引用中获取对象
	        System.out.println(userWeakRef.get());
	    }
	}

④. 虚引用: 对象回收跟踪

  • ①. 虚引用(Phantom Reference),也称为“幽灵引用”或者“幻影引用”,是所有引用类型中最弱的一个。

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

  • ③. 虚引用必须和引用队列一起使用。虚引用在创建时必须提供一个引用队列作为参数。当垃圾回收器准备回收一个对象时,如果发现它还有虛引用,就会在回收对象后,将这个虚引用加入引用队列,以通知应用程序对象的回收情况。虚引用的get方法总是返回给null,因此无法访问对应的引用对象 理解

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

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

	object obj = new object();
	ReferenceQueuephantomQueue = new ReferenceQueue( ) ;
	PhantomReference<object> pf = new PhantomReference<object>(obj, phantomQueue); 
	obj = null;
  • ⑥. 测试代码
/***
 * -xms10m -xmx10m
 */
public class MyObject {
    public static void main(String[] args) {

        ReferenceQueue<MyObject> referenceQueue = new ReferenceQueue();
        PhantomReference<MyObject> phantomReference = new PhantomReference<>(new MyObject(),referenceQueue);
        //System.out.println(phantomReference.get());

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

        new Thread(() -> {
            while (true)
            {
                list.add(new byte[1 * 1024 * 1024]);
                try { TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(phantomReference.get());
            }
        },"t1").start();

        new Thread(() -> {
            while (true)
            {
                Reference<? extends MyObject> reference = referenceQueue.poll();
                if (reference != null) {
                    //下面这句话被打印出说明进行了gc,然后将对象放在了引用队列中,我们可以使用poll方法获取
                    System.out.println("***********有虚对象加入队列了"+reference);
                }
            }
        },"t2").start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) { e.printStackTrace(); }

    }

    @Override
    protected void finalize() throws Throwable {
        // gc finalize method over 这句话被打印出来,说明进行了gc
        System.out.println("gc finalize method over");
    }
}
所得皆惊喜
关注
专栏目录
第 15 章 垃圾回收相关概念、System.gc()、内存溢出与内存泄漏、垃圾回收的并行与并发、强软弱虚引用
Guizy
02-12 584
第 15 章 垃圾回收相关概念 1、System.gc() 的理解 1.1、System.gc() 方法 System.gc() 方法 在默认情况下，通过System.gc()者Runtime.getRuntime().gc() 的调用，会显式触发Full GC，同时对老年代和新生代进行回收，尝试释放被丢弃对象占用的内存。 然而System.gc()调用附带一个免责声明，无法保证对垃圾收集器的调用(不能确保立即生效) JVM实现者可以通过System.gc() 调用来决定JVM的GC行为。而一般情况下
JVM相关 - 深入理解 System.gc()
Cr1556648487的博客
08-29 2108
本文基于 Java 17-ea，但是相关设计在 Java 11 之后是大致一样的我们经常在面试中询问 System.gc() 究竟会不会触发，网上也有很多人给出了答案，但是这些答案都有些过时了。本文基于最新的信息 Java 的下一个即将发布的 LTS 版本 Java 17（ea）的源代码，深入解析 System.gc() 背后的故事。...
深入理解Java虚拟机系列 --11 垃圾回收篇02 --垃圾回收相关概念深入理解
Free的午后
09-07 754
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 目录 1.System.gc()的理解 2.内存溢出(out of Memory) 3.内存泄漏(Memory Leak) 4.Stop The World 5.多线程中的并行与并发 6. 垃圾回收的并行、串行、并发 7.安全点(Safepoint) 8.安全区域(Safe Region) 1.System.gc()的理解 ①. 在默认情况下,通过System.gc( )或者Runtim...
JVM上篇：内存与垃圾回收篇-09-执行引擎
最新发布
yuanmomoya的博客
08-27 989
执行引擎属于 JVM 的下层，里面包括解释器、及时编译器、垃圾回收器执行引擎是 Java 虚拟机核心的组成部分之一。“虚拟机”是一个相对于“物理机”的概念，这两种机器都有代码执行能力，其区别是物理机的执行引擎是直接建立在处理器、缓存、指令集和操作系统层面上的，而虚拟机的执行引擎则是由软件自行实现的，因此可以不受物理条件制约地定制指令集与执行引擎的结构体系，能够执行那些不被硬件直接支持的指令集格式。JVM 的主要任务是负责装载字节码到其内部。
11 JVM 垃圾回收（上）
java程序员笔记
01-24 280
引用计数法和可达性分析 垃圾回收，就是将已经分配出去的，但却不在使用的内存回收回来，以便再次分配。在 Java 虚拟机语境下，垃圾指的是死亡的对象所占据的堆空间。下面就总结一下如何如何辨别一个对象是否死亡。 引用计数法：为每一个对象添加一个引用计数器，用来统计指向该对象的引用个数。如果某个对象的引用计数器为 0，则说明该对象已经死亡，便可以被回收了。 通过引用计数法来标记对象的死亡和存活的过程中，...
JVM—执行引擎
多一天，多一点
07-09 311
一、概述 执行引擎是Java虚拟机的核心组成部分之一。虚拟机是一个相对于“物理机”的概念，这两种机器都有代码执行能力，其区别是物理机的执行引擎是直接建立在处理器、缓存、指令集和操作系统层面上的，而虚拟机的执行引擎则是由软件自行实现的，因此可以不受物理条件制约地定制指令集与执行引擎的结构体系，能够执行那些不被硬件直接支持的指令集格式。 JVM的主要任务是负责装载字节码到其内部，但字节码并不能够直接运行在操作系统之上，因为字节码指令并非等价于本地机器指令，它内部包含的仅仅只是一些能够被JVM锁识别的字节码指令、
JVM:System.gc
syilt的博客
07-23 144
当我们调用System.gc()的时候，其实并不会马上进行垃圾回收，甚至不一定会执行垃圾回收，查看系统源码可以看到 /** * Indicates to the VM that it would be a good time to run the * garbage collector. Note that this is a hint only. There is no guarantee * that the garbage collector will ac
jvm_gc.rar_jvm_垃圾回收
09-24
1. **堆内存（Heap）**：这是JVM中最大的内存区域，用于存储对象实例。堆内存被所有线程共享，并且在JVM启动时创建。对象的分配和垃圾回收主要在堆上进行。 2. **年轻代（Young Generation）**：年轻代分为Eden区和...
JVM 内存管理及调优.zip_JVM内存_java_memory
09-23
JVM内存分为多个区域，包括堆内存、方法区、程序计数器、虚拟机栈和本地方法栈。理解这些区域的工作原理以及如何优化它们对于提升Java应用程序的性能至关重要。 1. **堆内存**：堆内存是Java对象的主要存储区域，...
JVM11_方法区、内存泄露和内存溢出
TimEcho的博客
10-19 644
方法区、栈、堆三者的关系 方法区如果保存了过多的类就会导致OOM 比如1、加载了大量的第三方jar包 2、tomcat服务器部署了过多工程(30-50个) 3、大量动态生成反射类 hotspot方法区的演进 如果方法区是接口，那么永久代或者元空间就是方法区的具体实现，只是JDK8中把永久代换成了元空间 元空间使用的是本地内存，而不是虚拟机内存 在hotspot中，可以认为方法区和永久代是等价的，因为hotspot对方法区的实现就是使用的永久代。 其他的虚拟机就没有永久代 方法区参数设置 jdk.
垃圾清理势在必行——java垃圾收集算法
走向WEB开发
01-03 587
 垃圾清理势在必行——java垃圾收集算法作者：zhangxinjie    出处：论坛整理 1.垃圾收集算法的核心思想　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。　　垃圾收集算法的核心思想是：对虚拟机可用内
一文读懂Java 11的ZGC为何如此高效
weixin_39639119的博客
08-13 5969
原文地址  https://mp.weixin.qq.com/s/nAjPKSj6rqB_eaqWtoJsgw   一文读懂Java 11的ZGC为何如此高效 原创： Sadiq Jaffer等 高可用架构 昨天 导读：GC是大部分现代语言内置的特性，Java 11 新加入的ZGC号称可以达到10ms 以下的 GC 停顿，本文作者对这一新功能进行了深入解析。同时还对还对这一新功能带来的其他...
JVM之内存溢出与内存泄漏
u010502101的博客
08-31 1465
文章目录1 内存溢出2 内存泄漏（Memory Leak） 1 内存溢出 内存溢出（OutOfMemoryError）就是JVM中没有空闲内存，垃圾回收器回收垃圾之后也无法提供足够的内存，导致内存溢出。 内存溢出一般由两方面导致：虚拟机的堆内存设置太小；内存中创建了很多大对象，垃圾回收器之后也不能回收足够的内存空间。 在发生OOM之前一般都会进行垃圾回收，如果能回收足够的内存空间就不会出现OOM异常；如果垃圾回收之后也不能回收足够空间，此时就会发生OOM。但是不是任何情况下，OOM之前都会触发垃圾回收，比如
System.gc()，JVM垃圾回收
积淀，为自己的梦想坚持--王辉
02-25 2187
1.垃圾收集算法的核心思想 　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别，如果对象正在被引用，那么称其为存活对象，反之，如果对象不再被
Java 新垃圾回收器深入学习 ZGC 01
郭传志的博客
12-08 301
GC是大部分现代语言内置的特性，Java 11 新加入的ZGC号称可以达到10ms 以下的 GC 停顿，本文作者对这一新功能进行了深入解析。同时还对还对这一新功能带来的其他可能性做了展望。ZGC是否可以达到该性能目标，请看高可用架构志愿者翻译的文章。 Java 11的新功能已经完全冻结，其中有些功能绝对非常令人兴奋，本文着重介绍ZGC。 Java 11包含一个全新的垃圾收集器–ZGC，它由Or...
【JVM调优】----内存溢出和内存泄漏
令仔很忙
11-05 3279
项目的开发，涉及到了服务器的运维，先来介绍下JVM相关的知识，也方便后期的使用。今天主要是说一说内存溢出和内存泄漏两件事。    内存溢出    从字面上来说，溢出，什么是溢出？就比如说你把一壶的水倒进一个小杯子里面，小杯子容量小，多出来的水就会溢出。就是你这个小杯子的容量撑不下你的一壶的水。用专业点的语言来说内存溢出，就是你申请内存容量的时候，系统无法给到你足够的内存容量大小，你申请了一个Inte
JVM性能调优-JVM内存整理及GC回收.pdf_java_jvm_
09-29
《JVM性能调优——JVM内存整理及GC回收》是针对Java开发人员的重要主题，尤其是在大型企业级应用中，确保JVM（Java虚拟机）的高效运行是至关重要的。本资料深入探讨了如何通过调整JVM内存设置和优化垃圾回收机制来...
JVM内存回收System.gc()
05-22 1028
1.垃圾收集算法的核心思想 　　Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。 　　垃圾收集算法的核心思想是：对虚拟机可用内存空间，即堆空间中的对象进行识别，如果对象正在被引用，那么称其为存活对象，反之，如果对象不再被
java server模式 设置_JVM client模式和Server模式
weixin_30994645的博客
02-16 553
我们把jdk安装完成后，在命名行输入java -version不仅可以看到jdk版本相关信息，还会看到类似与Java HotSpot(TM) 64-Bit Server VM (build 25.31-b07, mixed mode)这样的信息。其中有个Server VM (build 25.31-b07, mixed mode)其实代表了JVM的Server模式了。当然JVM还有一个Clie...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

所得皆惊喜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值