深入浅出JVM(十四)之内存溢出、泄漏与引用

简介: 深入浅出JVM(十四)之内存溢出、泄漏与引用

本篇文章将深入浅出的介绍Java中的内存溢出与内存泄漏并说明强引用、软引用、弱引用、虚引用的特点与使用场景

引用

在栈上的reference类型存储的数据代表某块内存地址,称reference为某内存、某对象的引用

实际上引用分为很多种,从强到弱分为:强引用 > 软引用 > 弱引用 > 虚引用

平常我们使用的引用实际上是强引用,各种引用有自己的特点,下文将一一介绍

强引用就是Java中普通的对象,而软引用、弱引用、虚引用在JDK中定义的类分别是SoftReferenceWeakReferencePhantomReference

下图是软引用、弱引用、虚引用、引用队列(搭配虚引用使用)之间的继承关系

image.png

内存溢出与内存泄漏

为了更清除的描述引用之间的作用,首先需要介绍一下内存溢出和内存泄漏

当发生内存溢出时,表示JVM没有空闲内存为新对象分配空间,抛出OutOfMemoryError(OOM)

当应用程序占用内存速度大于垃圾回收内存速度时就可能发生OOM

抛出OOM之前通常会进行Full GC,如果进行Full GC后依旧内存不足才抛出OOM

JVM参数-Xms10m -Xmx10m -XX:+PrintGCDetails

image.png

内存溢出可能发生的两种情况:

  1. 必须的资源确实很大,堆内存设置太小 (通过-Xmx来调整)
  2. 发生内存泄漏,创建大量对象,且生命周期长,不能被回收

内存泄漏Memory Leak: 对象不会被程序用到了,但是不能回收它们

对象不再使用并且不能回收就会一直占用空间,大量对象发生内存泄漏可能发生内存溢出OOM

广义内存泄漏:不正确的操作导致对象生命周期变长

  1. 单例中引用外部对象,当这个外部对象不用了,但是因为单例还引用着它导致内存泄漏
  2. 一些需要关闭的资源未关闭导致内存泄漏

强引用

强引用是程序代码中普遍存在的引用赋值,比如List list = new ArrayList();

只要强引用在可达性分析算法中可达时,垃圾收集器就不会回收该对象,因此不当的使用强引用是造成Java内存泄漏的主要原因

软引用

当内存充足时不会回收软引用

只有当内存不足时,发生Full GC时才将软引用进行回收,如果回收后还没充足内存则抛出OOM异常

JVM中针对不同的区域(年轻代、老年代、元空间)有不同的GC方式,Full GC的回收区域为整个堆和元空间

软引用使用SoftReference

内存充足情况下的软引用

     public static void main(String[] args) {
         int[] list = new int[10];
         SoftReference listSoftReference = new SoftReference(list);
         //[I@61bbe9ba
         System.out.println(listSoftReference.get());
     }

内存不充足情况下的软引用(JVM参数:-Xms5m -Xmx5m -XX:+PrintGCDetails)

 //-Xms5m -Xmx5m -XX:+PrintGCDetails
 public class SoftReferenceTest {
     public static void main(String[] args) {
         int[] list = new int[10];
         SoftReference listSoftReference = new SoftReference(list);
         list = null;
 ​
         //[I@61bbe9ba
         System.out.println(listSoftReference.get());
 ​
         //模拟空间资源不足
         try{
             byte[] bytes = new byte[1024 * 1024 * 4];
             System.gc();
         }catch (Exception e){
             e.printStackTrace();
         }finally {
             //null
             System.out.println(listSoftReference.get());
         }
     }
 }

弱引用

无论内存是否足够,当发生GC时都会对弱引用进行回收

弱引用使用WeakReference

内存充足情况下的弱引用

     public static void test1() {
         WeakReference<int[]> weakReference = new WeakReference<>(new int[1]);
         //[I@511d50c0
         System.out.println(weakReference.get());
 ​
         System.gc();
         
         //null
         System.out.println(weakReference.get());
     }

WeakHashMap

JDK中有一个WeakHashMap,使用与Map相同,只不过节点为弱引用

image.png

当key的引用不存在引用的情况下,发生GC时,WeakHashMap中该键值对就会被删除

     public static void test2() {
         WeakHashMap<String, String> weakHashMap = new WeakHashMap<>();
         HashMap<String, String> hashMap = new HashMap<>();
 ​
         String s1 = new String("3.jpg");
         String s2 = new String("4.jpg");
 ​
         hashMap.put(s1, "图片1");
         hashMap.put(s2, "图片2");
         weakHashMap.put(s1, "图片1");
         weakHashMap.put(s2, "图片2");
 ​
         //只将s1赋值为空时,堆中的3.jpg字符串还会存在强引用,所以要remove
         hashMap.remove(s1);
         s1=null;
         s2=null;
 ​
         System.gc();
 ​
         //4.jpg=图片2
         test2Iteration(hashMap);
 ​
         //4.jpg=图片2
         test2Iteration(weakHashMap);
     }
 ​
     private static void test2Iteration(Map<String, String>  map){
         Iterator iterator = map.entrySet().iterator();
         while (iterator.hasNext()){
            Map.Entry entry = (Map.Entry) iterator.next();
             System.out.println(entry);
         }
     }

未显示删除weakHashMap中的该key,当这个key没有其他地方引用时就删除该键值对

软引用,弱引用适用的场景

数据量很大占用内存过多可能造成内存溢出的场景

比如需要加载大量数据,全部加载到内存中可能造成内存溢出,就可以使用软引用、弱引用来充当缓存,当内存不足时,JVM对这些数据进行回收

使用软引用时,可以自定义Map进行存储Map<String,SoftReference<XXX>> cache

使用弱引用时,则可以直接使用WeakHashMap

软引用与弱引用的区别则是GC回收的时机不同,软引用存活可能更久,Full GC下才回收;而弱引用存活可能更短,发生GC就会回收

虚引用

使用PhantomReference创建虚引用,需要搭配引用队列ReferenceQueue使用

无法通过虚引用得到该对象实例(其他引用都可以得到实例)

虚引用只是为了能在这个对象被收集器回收时收到一个通知

引用队列搭配虚引用使用

 public class PhantomReferenceTest {
     private static PhantomReferenceTest reference;
     private static ReferenceQueue queue;
 ​
     @Override
     protected void finalize() throws Throwable {
         super.finalize();
         System.out.println("调用finalize方法");
         //搭上引用链
         reference = this;
     }
 ​
     public static void main(String[] args) {
         reference = new PhantomReferenceTest();
         //引用队列
         queue = new ReferenceQueue<>();
         //虚引用
         PhantomReference<PhantomReferenceTest> phantomReference = new PhantomReference<>(reference, queue);
         
         Thread thread = new Thread(() -> {
             PhantomReference<PhantomReferenceTest> r = null;
             while (true) {
                 if (queue != null) {
                     r = (PhantomReference<PhantomReferenceTest>) queue.poll();
                     //说明被回收了,得到通知
                     if (r != null) {
                         System.out.println("实例被回收");
                     }
                 }
             }
         });
         thread.setDaemon(true);
         thread.start();
 ​
 ​
         //null (获取不到虚引用)
         System.out.println(phantomReference.get());
 ​
         try {
             System.out.println("第一次gc 对象可以复活");
             reference = null;
             //第一次GC 引用不可达 守护线程执行finalize方法 重新变为可达对象
             System.gc();
             TimeUnit.SECONDS.sleep(1);
             if (reference == null) {
                 System.out.println("object is dead");
             } else {
                 System.out.println("object is alive");
             }
             reference = null;
             System.out.println("第二次gc 对象死了");
             //第二次GC 不会执行finalize方法 不能再变为可达对象
             System.gc();
             TimeUnit.SECONDS.sleep(1);
             if (reference == null) {
                 System.out.println("object is dead");
             } else {
                 System.out.println("object is alive");
             }
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
     }
 }

结果:

 /*
 null
 第一次gc 对象可以复活
 调用finalize方法
 object is alive
 第二次gc 对象死了
 实例被回收
 object is dead
 */

第一次GC时,守护线程执行finalize方法让虚引用重新可达,所以没死

第二次GC时,不再执行finalize方法,虚引用已死

虚引用回收后,引用队列有数据,来通知告诉我们reference这个对象被回收了

使用场景

GC只能回收堆内内存,而直接内存GC是无法回收的,直接内存代表的对象创建一个虚引用,加入引用队列,当这个直接内存不使用,这个代表直接内存的对象为空时,这个虚内存就死了,然后引用队列会产生通知,就可以通知JVM去回收堆外内存(直接内存)

总结

本篇文章围绕引用深入浅出的解析内存溢出与泄漏、强引用、软引用、弱引用、虚引用

当JVM没有足够的内存为新对象分配空间时就会发生内存溢出抛出OOM

内存溢出有两种情况,一种是分配的资源太少,不满足必要对象的内存;另一种是发生内存泄漏,不合理的设置对象的生命周期、不关闭资源都会导致内存泄漏

使用最常见的就是强引用,强引用只有在可达性分析算法中不可达时才会回收,强引用使用不当是造成内存泄漏的原因之一

使用SoftReference软引用时,只要内存不足触发Full GC时就会对软引用进行回收

使用WeakReference弱引用时,只要发生GC就会对弱引用进行回收

软、弱引用可以用来充当大数据情况下的缓存,它们的区别就是软引用可能活的更久Full GC才回收,使用弱引用时可以直接使用JDK中提供的WeakHashMap

虚引用无法在程序中获取,与引用队列搭配使用,当虚引用被回收时,能够从引用队列中取出(感知),可以在直接引用不使用时,发出消息让JVM进行回收

最后

  • 参考资料
  • 《深入理解Java虚拟机》

本篇文章将被收入JVM专栏,觉得不错感兴趣的同学可以收藏专栏哟~

觉得菜菜写的不错,可以点赞、关注支持哟~

有什么问题可以在评论区交流喔~

相关文章
|
1月前
|
存储 安全 Java
jvm 锁的 膨胀过程?锁内存怎么变化的
【10月更文挑战第3天】在Java虚拟机(JVM)中,`synchronized`关键字用于实现同步,确保多个线程在访问共享资源时的一致性和线程安全。JVM对`synchronized`进行了优化,以适应不同的竞争场景,这种优化主要体现在锁的膨胀过程,即从偏向锁到轻量级锁,再到重量级锁的转变。下面我们将详细介绍这一过程以及锁在内存中的变化。
37 4
|
3月前
|
Java Docker 索引
记录一次索引未建立、继而引发一系列的问题、包含索引创建失败、虚拟机中JVM虚拟机内存满的情况
这篇文章记录了作者在分布式微服务项目中遇到的一系列问题,起因是商品服务检索接口测试失败,原因是Elasticsearch索引未找到。文章详细描述了解决过程中遇到的几个关键问题:分词器的安装、Elasticsearch内存溢出的处理,以及最终成功创建`gulimall_product`索引的步骤。作者还分享了使用Postman测试接口的经历,并强调了问题解决过程中遇到的挑战和所花费的时间。
|
6天前
|
Arthas 监控 Java
JVM进阶调优系列(9)大厂面试官:内存溢出几种?能否现场演示一下?| 面试就那点事
本文介绍了JVM内存溢出(OOM)的四种类型:堆内存、栈内存、元数据区和直接内存溢出。每种类型通过示例代码演示了如何触发OOM,并分析了其原因。文章还提供了如何使用JVM命令工具(如jmap、jhat、GCeasy、Arthas等)分析和定位内存溢出问题的方法。最后,强调了合理设置JVM参数和及时回收内存的重要性。
|
4天前
|
Java Linux Windows
JVM内存
首先JVM内存限制于实际的最大物理内存,假设物理内存无限大的话,JVM内存的最大值跟操作系统有很大的关系。简单的说就32位处理器虽然可控内存空间有4GB,但是具体的操作系统会给一个限制,这个限制一般是2GB-3GB(一般来说Windows系统下为1.5G-2G,Linux系统下为2G-3G),而64bit以上的处理器就不会有限制。
8 1
|
1月前
|
缓存 算法 Java
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
这篇文章详细介绍了Java虚拟机(JVM)中的垃圾回收机制,包括垃圾的定义、垃圾回收算法、堆内存的逻辑分区、对象的内存分配和回收过程,以及不同垃圾回收器的工作原理和参数设置。
60 4
JVM知识体系学习六:JVM垃圾是什么、GC常用垃圾清除算法、堆内存逻辑分区、栈上分配、对象何时进入老年代、有关老年代新生代的两个问题、常见的垃圾回收器、CMS
|
1月前
|
存储 缓存 算法
JVM核心知识点整理(内存模型),收藏再看!
JVM核心知识点整理(内存模型),收藏再看!
JVM核心知识点整理(内存模型),收藏再看!
|
23天前
|
存储 算法 Java
聊聊jvm的内存结构, 以及各种结构的作用
【10月更文挑战第27天】JVM(Java虚拟机)的内存结构主要包括程序计数器、Java虚拟机栈、本地方法栈、Java堆、方法区和运行时常量池。各部分协同工作,为Java程序提供高效稳定的内存管理和运行环境,确保程序的正常执行、数据存储和资源利用。
46 10
|
22天前
|
存储 算法 Java
Java虚拟机(JVM)的内存管理与性能优化
本文深入探讨了Java虚拟机(JVM)的内存管理机制,包括堆、栈、方法区等关键区域的功能与作用。通过分析垃圾回收算法和调优策略,旨在帮助开发者理解如何有效提升Java应用的性能。文章采用通俗易懂的语言,结合具体实例,使读者能够轻松掌握复杂的内存管理概念,并应用于实际开发中。
|
1月前
|
存储 监控 算法
JVM调优深度剖析:内存模型、垃圾收集、工具与实战
【10月更文挑战第9天】在Java开发领域,Java虚拟机(JVM)的性能调优是构建高性能、高并发系统不可或缺的一部分。作为一名资深架构师,深入理解JVM的内存模型、垃圾收集机制、调优工具及其实现原理,对于提升系统的整体性能和稳定性至关重要。本文将深入探讨这些内容,并提供针对单机几十万并发系统的JVM调优策略和Java代码示例。
48 2
|
1月前
|
存储 Java
JVM知识体系学习四:排序规范(happens-before原则)、对象创建过程、对象的内存中存储布局、对象的大小、对象头内容、对象如何定位、对象如何分配
这篇文章详细地介绍了Java对象的创建过程、内存布局、对象头的MarkWord、对象的定位方式以及对象的分配策略,并深入探讨了happens-before原则以确保多线程环境下的正确同步。
53 0
JVM知识体系学习四:排序规范(happens-before原则)、对象创建过程、对象的内存中存储布局、对象的大小、对象头内容、对象如何定位、对象如何分配