Java内部类持有外部类导致内存泄露的原因与解决方案详解

目录
  • 简介
  • 为什么要持有外部类
  • 实例:持有外部类
  • 实例:不持有外部类
  • 实例:内存泄露
  • 不会内存泄露的方案

简介

说明

本文介绍Java内部类持有外部类导致内存泄露的原因以及其解决方案。

为什么内部类持有外部类会导致内存泄露?

非静态内部类会持有外部类,如果有地方引用了这个非静态内部类,会导致外部类也被引用,垃圾回收时无法回收这个外部类(即使外部类已经没有其他地方在使用了)。

解决方案

1.不要让其他的地方持有这个非静态内部类的引用,直接在这个非静态内部类执行业务。

2.将非静态内部类改为静态内部类。

内部类改为静态的之后,它所引用的对象或属性也必须是静态的,所以静态内部类无法获得外部对象的引用,只能从 JVM 的 Method Area(方法区)获取到static类型的引用。

相关网址

匿名内部类的内存泄露:Java的匿名内部类导致内存泄露--原因/解决方案

为什么要持有外部类

Java 语言中,非静态内部类的主要作用有两个:

当内部类只在外部类中使用时,匿名内部类可以让外部不知道它的存在,从而减少了代码的维护工作。

当内部类持有外部类时,它就可以直接使用外部类中的变量了,这样可以很方便的完成调用,如下代码所示:

package org.example.a;

class Outer{
    private String outerName = "Tony";

    class Inner{
        private String name;

        public Inner() {
            this.name = outerName;
        }
    }

    Inner createInner() {
        return new Inner();
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().createInner();
        System.out.println(inner);
    }
}

但是,静态内部类就无法持有外部类和其非静态字段了。比如下边这样就会报错

package org.example.a;

class Outer{
    private String outerName = "Tony";

    static class Inner{
        private String name;

        public Inner() {
            this.name = outerName;
        }
    }

    Inner createInner() {
        return new Inner();
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().createInner();
        System.out.println(inner);
    }
}

报错:

实例:持有外部类

代码

package org.example.a;

class Outer{
    class Inner {

    }

    Inner createInner() {
        return new Inner();
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().createInner();
        System.out.println(inner);
    }
}

断点调试

可以看到:内部类持有外部类的对象的引用,是以“this$0”这个字段来保存的。

实例:不持有外部类

代码

package org.example.a;

class Outer{
    static class Inner {

    }

    Inner createInner() {
        return new Inner();
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().createInner();
        System.out.println(inner);
    }
}

断点调试

可以发现:内部类不再持有外部类了。

实例:内存泄露

简介

若内部类持有外部类的引用,对内部类的使用很多时,会导致外部类数目很多。此时,就算是外部类的数据没有被用到,外部类的数据所占空间也不会被释放。

本处在外部类存放大量的数据来模拟。

代码

package org.example.a;

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

class Outer{
    private int[] data;

    public Outer(int size) {
        this.data = new int[size];
    }

    class Innner{

    }

    Innner createInner() {
        return new Innner();
    }
}

public class Demo {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        int counter = 0;
        while (true) {
            list.add(new Outer(100000).createInner());
            System.out.println(counter++);
        }
    }
}

测试

可以看到:运行了八千多次的时候就内存溢出了。

不会内存泄露的方案

简介

内部类改为静态的之后,它所引用的对象或属性也必须是静态的,所以静态内部类无法获得外部对象的引用,只能从 JVM 的 Method Area(方法区)获取到static类型的引用。

代码

package org.example.a;

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

class Outer{
    private int[] data;

    public Outer(int size) {
        this.data = new int[size];
    }

    static class Inner {

    }

    Inner createInner() {
        return new Inner();
    }
}

public class Demo {
    public static void main(String[] args) {
        List<Object> list = new ArrayList<>();
        int counter = 0;
        while (true) {
            list.add(new Outer(100000).createInner());
            System.out.println(counter++);
        }
    }
}

测试

可以发现:循环了四十多万次都没有内存溢出。

以上就是Java内部类持有外部类导致内存泄露的原因与解决方案详解的详细内容,更多关于Java内存泄露的资料请关注我们其它相关文章!

(0)

相关推荐

  • Java中的内存泄露问题和解决办法

    目录 为什么会产生内存泄漏? 内存泄漏对程序的影响? 如何检查和分析内存泄漏? 常见的内存泄漏及解决方法 1.单例造成的内存泄漏 2.非静态内部类创建静态实例造成的内存泄漏[已无] 3.Handler造成的内存泄漏 4.线程造成的内存泄漏 5.资源未关闭造成的内存泄漏 6.使用ListView时造成的内存泄漏 7.集合容器中的内存泄露 8.WebView造成的泄露 如何避免内存泄漏? 总结 (Memory Leak,内存泄漏) 为什么会产生内存泄漏? 当一个对象已经不需要再使用本该被回收时,另外

  • java外部类与内部类简介

     一.内部类 内部类就是将一个类A定义在类B里边,里边的那个类A称为内部类,外边的类B称为外部类 成员内部类定义格式: class 外部类{ class 内部类{ } } class A{ class B{ } } 在描述一个事物是,事物的里边还有另外一个事物就可以用到内部类 访问特点: 1.内部类可以直接访问外部类的成员,包括私有成员. 2.外部类要访问内部类的成员,必须要建立内部类的对象. 创建内部类格式: 外部类.内部类 对象名=new 外部类型().new 内部类型(); 二.匿名内部类

  • Java语言中的内存泄露代码详解

    Java的一个重要特性就是通过垃圾收集器(GC)自动管理内存的回收,而不需要程序员自己来释放内存.理论上Java中所有不会再被利用的对象所占用的内存,都可以被GC回收,但是Java也存在内存泄露,但它的表现与C++不同. JAVA中的内存管理 要了解Java中的内存泄露,首先就得知道Java中的内存是如何管理的. 在Java程序中,我们通常使用new为对象分配内存,而这些内存空间都在堆(Heap)上. 下面看一个示例: public class Simple { public static vo

  • java外部类与内部类的关系详解

     private,public,protected,default的访问权限区别 在学习外部类与内部类之前我们首先要弄明白private,public,protected,default在访问权限上有什么不同,这对我们之后的理解会有一定的帮助. 1.private:访问权限最低的访问控制符,被它修饰的变量只能访问本类的对象. 2.public:访问权限最高,不仅是本类,子类,本包,其他的包,都可以去访问它修饰的对象. 3.default:访问权限限制在本类以及本包内. 4.protected:访

  • java的内部类和外部类用法讲解

    目录 一.为何使用内部类 二.内部类与外部类的联系 2.1 内部类是一个相对独立的实体,与外部类不是is-a关系 2.2 内部类可以直接访问外部类的元素,但是外部类不可以直接访问内部类的元素 2.3 外部类可以通过内部类引用间接访问内部类元素 三.创建内部类 3.1 在外部类外面(或外部类main方法)创建内部了对象 3.2 在外部类里面创建内部类 四.内部类的种类: 4.1 成员内部类 4.2 方法内部类 4.3 匿名内部类 4.4 静态内部类 一.为何使用内部类 内部类提供了更好的封装,只有

  • 深入聊聊Java内存泄露问题

    目录 Java内存泄露问题 附:内存泄露的典型情况 总结 Java内存泄露问题 所谓内存泄露就是指一个不再被程序便用的对象或变量一直被占据在内存中. Java 中有垃圾回收机制,它可以保证一对象不再被引用的时候,即对象变成了孤儿的时候,对象将自动被垃圾回收器从内存中清除掉. 既然java有垃圾回收机制,为什么还会存在内存泄漏的问题呢? 无非,就是有些对象,无法被垃圾回收器处理,导致这些对象一直占用JVM内存,那不就导致内存泄漏了嘛. 由于 Java 使用有向图的方式进行垃圾回收管理,可以消除引用

  • Java内部类持有外部类导致内存泄露的原因与解决方案详解

    目录 简介 为什么要持有外部类 实例:持有外部类 实例:不持有外部类 实例:内存泄露 不会内存泄露的方案 简介 说明 本文介绍Java内部类持有外部类导致内存泄露的原因以及其解决方案. 为什么内部类持有外部类会导致内存泄露? 非静态内部类会持有外部类,如果有地方引用了这个非静态内部类,会导致外部类也被引用,垃圾回收时无法回收这个外部类(即使外部类已经没有其他地方在使用了). 解决方案 1.不要让其他的地方持有这个非静态内部类的引用,直接在这个非静态内部类执行业务. 2.将非静态内部类改为静态内部

  • Java中ThreadLocal 导致内存 OOM 的原因分析

    目录 原因分析 正确的使用方式 原因分析 ThreadLocal 导致内存 OOM 的原因是什么? ThreadLocal 底层通过 ThreadLocalMap 存储数据 源码如下:  当我们使用ThreadLocal.set()时,set的value与key(即业务自己定义的ThreadLocal类)会存储在ThreadLocalMap的Entry[]数组里 源码如下: 其中Entry是实现了一个弱引用WeakReference,Entry的key(即业务方定义的 ThreadLocal类)

  • C语言内存泄露很严重的解决方案

    目录 1.前言 2.内存泄漏问题原理 2.1堆内存在C代码中的存储方式 2.2堆内存的获取方法 2.3内存泄漏三要素 2.4内存释放误区 3.内存泄漏问题检视方法 1.前言 最近部门不同产品接连出现内存泄漏导致的网上问题,具体表现为单板在现网运行数月以后,因为内存耗尽而导致单板复位现象. 一方面,内存泄漏问题属于低级错误,此类问题遗漏到现网,影响很坏:另一方面,由于内存泄漏问题很可能导致单板运行固定时间以后就复位,只能通过批量升级才能解决,实际影响也很恶劣. 同时,接连出现此类问题,尤其是其中一

  • Java @Async注解导致spring启动失败解决方案详解

    前言 在这篇文章里,最后总结处,我说了会讲讲循环依赖中,其中一个类添加@Async有可能会导致注入失败而抛异常的情况,今天就分析一下. 一.异常表现,抛出内容 1.1循环依赖的两个class 1.CycleService1 @Service public class CycleService1 { @Autowired private CycleService2 cycleService2; @WangAnno @Async public void doThings() { System.out

  • Java并发编程深入理解之Synchronized的使用及底层原理详解 下

    目录 一.synchronized锁优化 1.自旋锁与自适应自旋 2.锁消除 逃逸分析: 3.锁粗化 二.对象头内存布局 三.synchronized锁的膨胀升级过程 1.偏向锁 2.轻量级锁 3.重量级锁 4.各种锁的优缺点 接着上文<Java并发编程深入理解之Synchronized的使用及底层原理详解 上>继续介绍synchronized 一.synchronized锁优化 高效并发是从JDK 5升级到JDK 6后一项重要的改进项,HotSpot虚拟机开发团队在这个版本上花费了大量的资源

  • java并发编程专题(十)----(JUC原子类)基本类型详解

    这一节我们先来看一下基本类型: AtomicInteger, AtomicLong, AtomicBoolean.AtomicInteger和AtomicLong的使用方法差不多,AtomicBoolean因为比较简单所以方法比前两个都少,那我们这节主要挑AtomicLong来说,会使用一个,其余的大同小异. 1.原子操作与一般操作异同 我们在说原子操作之前为了有个对比为什么需要这些原子类而不是普通的基本数据类型就能满足我们的使用要求,那就不得不提原子操作不同的地方. 当你在操作一个普通变量时,

  • Java并发编程深入理解之Synchronized的使用及底层原理详解 上

    目录 一.线程安全问题 1.临界资源 2.线程安全问题 3.如何解决线程安全问题 二.synchronized使用介绍 三.synchronized实现原理 1.synchronized底层指令:monitorenter和monitorexit 2.Object Monitor(监视器锁)机制 一.线程安全问题 1.临界资源 多线程编程中,有可能会出现多个线程同时访问同一个共享.可变资源的情况,这个资源我们称之其为临界资源:这种资源可能是:对象.变量.文件等. 共享:资源可以由多个线程同时访问

  • C语言动态内存管理malloc柔性数组示例详解

    目录 1.1为什么存在动态内存管理 1.2动态内存管理函数 1.2.1malloc 1.2.2free 1.2.3calloc 1.2.4realloc 1.3动态内存管理函数易错点 1.3.1对NULL指针的解引用操作 1.3.2对动态开辟空间的越界访问 1.3.3对非动态开辟内存使用free释放 1.3.4使用free释放一块动态开辟内存的一部分 1.3.5对同一块动态内存多次释放 1.3.6动态开辟内存忘记释放(内存泄漏) 2.1常见相关笔试题 2.2C/C++语言中的内存开辟 2.3柔性

  • Linux监控cpu以及内存使用情况之top命令(详解)

    top命令是Linux下常用的性能分析工具,比如cpu.内存的使用,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器. top显示系统当前的进程和其他状况,是一个动态显示过程,即可以通过用户按键来不断刷新当前状态.如果在前台执行该命令,它将独占前台,直到用户终止该程序为止. 比较准确的说,top命令提供了实时的对系统处理器的状态监视.它将显示系统中CPU最"敏感"的任务列表.该命令可以按CPU使用.内存使用和执行时间对任务进行排序:而且该命令的很多特性都可以通

随机推荐