[移动开发] 【Java】JVM运行时数据区域与内存回收机制

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 移动开发 -> 【Java】JVM运行时数据区域与内存回收机制 -> 正文阅读

[移动开发]【Java】JVM运行时数据区域与内存回收机制

前言

JVM(Java Virtual Machine)是Java、Kotlin、Groovy等程序运行的虚拟机，它是Java技术系统里最重要的组成部分之一。熟悉JVM的运行过程、运行时数据区以及内存回收机制，对我们认识Java语言，解决内存泄漏、内存溢出等问题非常有帮助。

一、Java技术体系

从广义上讲，Java、Kotlin、Scala、Clojure、JRuby、Groovy等运行于Java虚拟机上的编程语言及其相关的程序都属于Java技术体系中的一员。如果仅从传统意义上来看，Java技术体系包括了以下几个组成部分:

Java程序设计语言
各种硬件平台上的Java虚拟机实现
Class文件格式
Java类库API
来自商业机构和开源社区的第三方类库

Java技术的优点：

结构严谨、面向对象
跨平台，“一次编写、到处运行”
自动内存管理
热点代码检测、运行时编译优化
有一套完善的应用程序接口和三方类库

二、Java运行时数据区域

Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。这些区域有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而一直存在，有些区域则是依赖用户线程的启动和结束而建立和销毁。根据《Java虚拟机规范》的规定，Java虚拟机所管理的内存将会包括以下几个运行时数据区域。

在这里插入图片描述

(1) 程序计数器

程序计数器(Program Counter Register)是一块较小的内存空间，它可以看作是当前线程所执行的字节码的行号指示器。由于Java虚拟机的多线程是通过线程轮流切换、分配处理器执行时间的方式来实现的，在任何一个确定的时刻，一个处理器(对于多核处理器来说是一个内核)都只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。

(2) Java虚拟机栈

与程序计数器一样，Java虚拟机栈也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的线程内存模型:每个方法被执行的时候，Java虚拟机都会同步创建一个栈帧用于存储局部变量表、操作数栈、动态连接、方法出口等信息。每一个方法被调用直至执行完毕的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

局部变量表存放了编译期可知的各种Java虚拟机基本数据类型(boolean、byte、char、short、int、 float、long、double)、对象引用(reference类型，它并不等同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或者其他与此对象相关的位置)和returnAddress 类型(指向了一条字节码指令的地址)

Java虚拟机栈内存区域规定了两类异常状况:

如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常;
线程申请栈空间超过JVM剩余内存，将抛出OutOfMemoryError异常。

虚拟机栈内存大小由-Xss参数指定

(3) 本地方法栈

本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的，其区别只是虚拟机栈为虚拟机执行Java方法(也就是字节码)服务，而本地方法栈则是为虚拟机使用到的本地(Native) 方法服务。《Java虚拟机规范》对本地方法栈中方法使用的语言、使用方式与数据结构并没有任何强制规定，因此具体的虚拟机可以根据需要自由实现它，甚至有的Java虚拟机(譬如Hot-Spot虚拟机)直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈也会在栈深度溢出或者栈扩展失败时分别抛出StackOverflowError和OutOfMemoryError异常。

(4) Java堆

对于Java应用程序来说，Java堆(Java Heap)是虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，Java世界里“几乎”所有的对象实例都在这里分配内存。在《Java虚拟机规范》中对Java堆的描述是：“所有的对象实例以及数组都应当在堆上分配。”
Java堆既可以被实现成固定大小的，也可以是可扩展的，不过当前主流的Java虚拟机都是按照可扩展来实现的(通过参数-Xmx和-Xms设定)。如果在Java堆中没有内存完成实例分配，并且堆也无法再扩展时，Java虚拟机将会抛出OutOfMemoryError异常。

Java堆内存大小参数：

-Xmx：最大内存

-Xms：初始内存

-Xmn Java Heap Young区大小

eg：java -Xmx128m -Xms64m -Xmn32m -Xss128k Test

(5) 方法区

方法区(Method Area)也叫“永久代”，与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。相对而言，垃圾收集行为在这个区域的确是比较少出现的，但并非数据进入了方法区就如永久代的名字一样“永久”存在了。这区域的内存回收目标主要是针对常量池的回收和对类型的卸载。

方法区内存大小设置参数如下

-XX:PermSize=56m，-XX:MaxPermSize=128m

(6) 运行时常量池

运行时常量池(Runtime Constant Pool)是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池表(Constant Pool Table)，用于存放编译期生成的各种字面量与符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。

运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是说，并非预置入Class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可以将新的常量放入池中，这种特性被开发人员利用得比较多的便是St ring类的intern()方法。

intern()方法的作用：When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

思考题1：

String s=new String("abc") //创建了几个对象？

提示：使用双引号声明的字符串对象，是放在字符串常量池中，new关键字创建的对象存放在堆内存中。

思考题2:

Integer a = 200, b = 200;
System.out.println(a == b);//打印true还是false?
a = 100;
b = 100;
System.out.println(a == b);//打印true还是false?

提示：java中Integer有一个常量池范围-128~127

思考题3：

        String str1 = "abc";
        String str2 = "abc";
        System.out.println("str1==str2:" + (str1 == str2));  //打印true
        
        String str3 = new String("abc");
        System.out.println("str1==str3:" + (str1 == str3)); //打印false
        System.out.println("str1==str3.intern():" + (str1 == str3.intern())); //打印true
        System.out.println("str2==str3.intern():" + (str2 == str3.intern())); //打印true
        
        String str4 = new String("abc");
        System.out.println("str3==str4:" + (str3 == str4));//打印false
        System.out.println("str3.intern()==str4.intern():" + (str3.intern() == str4.intern()));
        //打印true

        String str5 = new StringBuilder("程序").append("员").toString();
        System.out.println("str5.intern() == str5:" + (str5.intern() == str5));//打印true

        String str6 = new String(new StringBuilder("中").append("国").toString());
        System.out.println("str6.intern() == str6:" + (str6.intern() == str6));//打印true

        String str7 = new String("工程师");
        System.out.println("str7.intern() == str7:" + (str7.intern() == str7));//打印false

思考题4：虚拟机栈发生StackOverFlowError，是否可以通过增大虚拟机栈内存容量解决？

三、JVM内存回收机制

jvm运行时数据区中程序计数器、虚拟机栈、本地方法栈随着线程而生，随着线程而灭，栈中的栈帧随着方法的进入和退出有条不紊地执行入栈和出栈的操作。这几个区域内存分配和回收具有确定性，不需要过多考虑内存分配和回收的问题，因为方法结束或者线程线束时内存自然就回收了。而Java堆和方法区就不一样，这些区域的内存分配和回收是动态的，垃圾收集器主要关注的这是两个部分的内存。

(1) 如何判定内存是否需要回收

1、引用计数法

在对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加一; 当引用失效时，计数器值就减一;任何时刻计数器为零的对象就是不可能再被使用的。在Java 领域，至少主流的Java虚拟机里面都没有选用引用计数算法来管理内存，主要原因是，这个看似简单的算法有很多例外情况要考虑，必须要配合大量额外处理才能保证正确地工作，譬如单纯的引用计数就很难解决对象之间相互循环引用的问题。

2、可达性分析算法(根搜索算法)

当前主流的商用程序语言(Java、C#)的内存管理子系统，都是通过可达性分析(Reachability Analysis)算法来判定对象是否存活的。这个算法的基本思路就是通过一系列称为“GC Roots”的根对象作为起始节点集，从这些节点开始，根据引用关系向下搜索，搜索过程所走过的路径称为“引用链”(Reference Chain)，如果某个对象到GC Roots间没有任何引用链相连，或者用图论的话来说就是从GC Roots到这个对象不可达时，则证明此对象是不可能再被使用的。

如图所示，对象object 5、object 6、object 7虽然互有关联，但是它们到GC Roots是不可达的，因此它们将会被判定为可回收的对象。

在这里插入图片描述

在Java语言里，可以作为GC Roorts的对象包括下面几种：

在虚拟机栈(栈帧中的本地变量表)中引用的对象。譬如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。
在方法区中类静态属性引用的对象。譬如Java类的引用类型静态变量。
在方法区中常量引用的对象。譬如字符串常量池(String Table)里的引用。
在本地方法栈中JNI(即通常所说的Native方法)引用的对象。

(2) 引用分类

一个对象只有“被引用”或者“未被引用”两种状态，对于描述一些“食之无味，弃之可惜”的对象就显得无能为力。譬如我们希望能描述一类对象:当内存空间还足够时，能保留在内存之中，如果内存空间在进行垃圾收集后仍然非常紧张，那就可以抛弃这些对象——很多系统的缓存功能都符合这样的应用场景。在JDK 1.2版之后，Java对引用的概念进行了扩充，将引用分为强引用(Strongly Re-ference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种，这4种引用强度依次逐渐减弱。

强引用：强引用是最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj=new Object()”这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。
软引用：软引用是用来描述一些还有用，但非必须的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK 1.2版之后提供了SoftReference类来实现软引用。
弱引用：弱引用也是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生为止。当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2版之后提供了WeakReference类来实现弱引用。
虚引用：虚引用也称为“幽灵引用”或者“幻影引用”，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知。在JDK 1.2版之后提供了Phant omReference类来实现虚引用。

(3) 垃圾收集算法

1、标记-清除算法
算法分为“标记”和“清除”两个阶段:首先标记出所有需要回收的对象，在标记完成后，统一回收掉所有被标记的对象，也可以反过来，标记存活的对象，统一回收所有未被标记的对象。

在这里插入图片描述

2、标记-复制算法
标记-复制算法常被简称为复制算法。为了解决标记-清除算法面对大量可回收对象时执行效率低的问题，1969年Fenichel提出了一种称为“半区复制”(Semispace Copying)的垃圾收集算法，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。如果内存中多数对象都是存活的，这种算法将会产生大量的内存间复制的开销，但对于多数对象都是可回收的情况，算法需要复制的就是占少数的存活对象，而且每次都是针对整个半区进行内存回收，分配内存时也就不用考虑有空间碎片的复杂情况，只要移动堆顶指针，按顺序分配即可。这样实现简单，运行高效，不过其缺陷也显而易见，这种复制回收算法的代价是将可用内存缩小为了原来的一半，空间浪费未免太多了一点。HotSpot虚拟机默认Eden和Survivor的大小比例是8∶1，也即每次新生代中可用内存空间为整个新生代容量的90%(Eden的80%加上一个Survivor的10%)，只有一个Survivor空间，即10%的新生代是会被“浪费”的。
现在的商用Java虚拟机大多都优先采用了这种收集算法去回收新生代。

在这里插入图片描述

3、标记-整理算法

标记-复制算法在对象存活率较高时就要进行较多的复制操作，效率将会降低。更关键的是，如果不想浪费50%的空间，就需要有额外的空间进行分配担保，以应对被使用的内存中所有对象都100%存活的极端情况，所以在老年代一般不能直接选用这种算法。针对老年代对象的存亡特征，1974年Edward Lueders提出了另外一种有针对性的“标记-整理”(Mark-Compact)算法，其中的标记过程仍然与“标记-清除”算法一样，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向内存空间一端移动，然后直接清理掉边界以外的内存，“标记-整理”算法的示意图如图3-4所示。
标记-清除算法与标记-整理算法的本质差异在于前者是一种非移动式的回收算法，而后者是移动式的。

在这里插入图片描述

四、Java虚拟机与Android虚拟机的区别

(1)、执行的字节码不同

Java虚拟机执行的是class字节码(jar)，Android执行的是dex字节码。dex文件删除了大量字节码冗余信息，相比jar体积更小，类查找速度更快。

class字节码由dx工具转换成dex字节码

(2)、编译方式不同

Java虚拟机采用JIT(Just In Time)编译方式，android 5.0以后使用art虚拟机，采用静态提前编译AOT(Ahead Of Time)的方式。AOT相比JIT，应用启动和运行速度更快，体验更流畅，但是占用存储空间会变大，应用的安装时间也会变长。

五、Android内存泄漏案例分析

(1) 内部类和线程造成的内存泄漏

public class MainActivity extends AppCompatActivity {
  @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        loadData();
    }

    private void loadData() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                SystemClock.sleep(30000);
            }
        }).start();
    }

}

提示：非静态内部类默认持有外部类引用(查看字节码可验证)。
解决思路：将匿名内部类Runnable声明成static实名类，需要使用activity时使用WeakReference包装。或者在activity退出时将线程终止。

(2) Handler造成的内存泄漏

public class MainActivity extends AppCompatActivity {
    private final Handler handler = new Handler(Looper.myLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        handler.postDelayed(new Runnable() {
            @Override
            public void run() {

            }
        }, 30000);
    }

(3) Timer和TimerTask造成的内存泄漏

(4) AsyncTask造成的内存泄漏

(5) 属性动画造成的内存泄漏

(6) 单例造成的内存泄漏

(7) 静态变量引用context造成的内存泄漏

(8) 其它

六、Android内存泄漏分析工具

(1) LeakCanary

(2) Android Studio Profiler

(3 )DDMS

(4 )MAT

思考题答案：
思考题1：两个。
思考题2：false和true。引用类型双等号比较的是引用，基本类型双等号比较的是值。如果Integer想比较值必须要转化成int类型，通过调用intValue()即可。
思考题3：jdk1.8常量池存放在堆内存中，而不是方法区中，并且调用inern()方法是将堆内存的字符串引用复制到常量池，而不是复制字符串对象。
思考题4：不建议增大栈内存容量解决StackOverFlowError，因为增大栈内存容量意味着每个线程占用的内存越大，可创建的线程数量就会越少，反而容易引发OOM异常。建议通过优化代码解决。