JVM

后端

发布日期: 2022-07-06

更新日期: 2022-07-06

文章字数: 3.2k

阅读时长: 12 分

阅读次数:

JVM（一）：内存结构

一、JVM概述

定义

Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）

好处

一次编写，到处运行
自动内存管理，垃圾回收机制
数组下标越界检查

JVM JRE JDK的比较

二、内存结构

整体结构

程序计数器PC

定义：Program Counter Register 程序计数器（寄存器）
作用：==记录JVM中要执行的下一条指令的地址==
特点：
- 线程私有
  - CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
  - 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
- 不会存在内存溢出

虚拟机栈

定义：
- 每个线程运行所需要的内存空间称为虚拟机栈；
- 每个栈由多个栈帧组成，对应着每次调用方法时所占用的内存；
- 每个线程只能有一个活动栈帧，对应着当前正在执行的方法，会处于虚拟机栈的栈顶。
调整栈空间大小：
```
-Xss空间大小
-Xss8M
```
实例：
常见问题辨析：
- 垃圾回收是否涉及栈内存？
  - 不需要，因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
- 栈内存的分配越大越好吗？
  - 不是。因为物理内存是一定的，栈空间越大，会导致线程数越少。栈空间越大，也并不会让程序更快，只是有更大的栈空间，能让你做更多次的递归调用。
- 方法内的局部变量是否是线程安全的？
  - 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的；
  - 如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题。
  示例：
栈内存溢出Java.lang.stackOverflowError
- 原因：
  - 虚拟机栈中，栈帧过多（无限递归，或互相调用、无限循环）
  - 每个栈帧所占用过大
线程运行诊断

以CUP占用过高为例：
- Linux环境下运行某些程序的时候，可能导致CPU的占用过高，这时需要定位占用CPU过高的线程
  - top命令：查看是哪个进程占用CPU过高
  - ps H -eo pid, tid（线程id）, %cpu | grep 刚才通过top查到的进程号 ：通过ps命令进一步查看是哪个线程占用CPU过高
  - jstack 进程id ：通过查看进程中的线程的nid，刚才通过ps命令看到的tid来对比定位问题代码，注意jstack查找出的线程id是16进制的，需要转换。

本地方法栈

native 本地方法

本地方法栈，给本地方法的运行提供一个空间。jvm类并不是所有的方法都是java代码编写的，有些底层的方法就是通过c/c++实现的。而java可以调用这些底层方法来完成一些功能。在java调用这些底层方法时，就是运行在本地方法栈中。

堆

定义：通过new关键字创建的对象都会被放在堆内存
特点：
- 所有线程共享，堆内存中的对象都需要考虑线程安全问题
- 有垃圾回收机制
调整堆空间大小
```
-Xmx空间大小
-Xmx4G
```
堆内存溢出：java.lang.OutofMemoryError ：java heap space.
堆内存诊断
1. jps工具
  - 查看当前系统中有哪些java进程
2. jmap工具
  - 查看某一时刻堆内存占用情况
  - jhsdb jmap --heap --pid 进程id
3. jconsole工具
  - 图形界面的，多功能的监测工具，可以连续监测
4. 堆内存调整指令参数
  - -Xmx容量大小

方法区

方法区是一种规范，永久代和元空间都只是它的实现。

结构
内存溢出
- JDK1.8前，会出现永久代（在方法区中）溢出；
- JDK1.8侯，会出现元空间（在本地内存中）溢出。
- 调整元空间大小：-XX:MaxMetaspaceSize=8m
常量池和运行时常量池
- 常量池：就是一张表，虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
- 运行时常量池：常量池是*.class文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址。
通过反编译来查看类的信息
- 进入java目录下，用javac编译java文件，如：javac User.java，生成二进制字节码：User.class文件；
- 使用javap反汇编工具查看字节码文件，如：javap -v User.class，之后就可以看到字节码文件的详细内容了。
查看字节码文件示例：
- 类的基本信息
- 常量池
- 虚拟机中执行编译的方法（**#号的内容需要在常量池中查找**，根据#及数字，可查到使用的内容）

串池StringTable:用来放字符串对象且里面的元素不重复

特征：
- 常量池中的字符串仅是符号（类加载时加入串池），只有在被用到时才会转化为对象（懒加载）；
- 利用串池的机制，来避免重复创建字符串对象；
- 字符串变量拼接的原理是StringBuilder；
- 字符串常量拼接的原理是编译器优化；
- 可以使用intern方法，主动将串池中还没有的字符串对象放入串池中；
- 注意：无论是串池还是堆里面的字符串，都是对象。

串池使用示例：

对于以下代码：

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a"; 
		String b = "b";
		String ab = "ab";
	}
}

// 常量池中的信息，都会被加载到运行时常量池中，
// 这时 a b ab 都是常量池中的符号，还没有变为 java 字符串对象
// ldc #2 会把 a 符号变为 "a" 字符串对象
// ldc #3 会把 b 符号变为 "b" 字符串对象
// ldc #4 会把 ab 符号变为 "ab" 字符串对象
// 最终StringTable [“a”, “b”, “ab”]

//字节码文件内容为
0: ldc           #2                  // String a
2: astore_1
3: ldc           #3                  // String b
5: astore_2
6: ldc           #4                  // String ab
8: astore_3
9: return

字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中。

对于字符串拼接代码：

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a";
		String b = "b";
		String ab = "ab";
		//拼接字符串对象来创建新的字符串
		String ab2 = a+b; 
         //使用拼接字符串的方法创建字符串
		String ab3 = "a" + "b";
        
        //结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，
        //存在于堆内存之中，不是同一个对象
		System.out.println(ab == ab2); //fasle
        
        //结果为true,因为ab存在于串池之中，ab3直接引用串池中的 ab，是同一个对象
		System.out.println(ab == ab3); //true
	}
}


//字节码文件
 	  Code:
      stack=2, locals=6, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: new           #5                  // class java/lang/StringBuilder
        12: dup
        13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        // 使用 StringBuilder 来实现字符串拼接
        17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: invokevirtual #8            // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        27: astore        4
        //ab3初始化时直接从串池中获取字符串
        29: ldc           #4                  // String ab
        31: astore        5
        33: return

由此可见：

通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中；
使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致；
使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建。

intern方法：调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
- 在JDK1.8中：如果串池中没有该字符串对象，则放入成功；如果有该字符串对象，则放入失败，无论放入是否成功，都会返回串池中的字符串对象，此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象。
- 在JDK1.6中：如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中；如果有该字符串对象，则放入失败，无论放入是否成功，都会返回串池中的字符串对象，此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象。

String Table位置
- 在1.6之前。StringTable在方法区永久代中，但是放在这之中，虚拟机只会在full GC时才会对StringTable进行垃圾回收。但是其实StringTable的操作是非常频繁的，如果没有即使进行垃圾回收，容易造成永久代空间不足。
- 在1.8后，StringTable放在了堆中，使其垃圾回收的效率更高。
StringTable垃圾回收

StringTable在内存紧张时，会清理一些未引用的字符串常量。
StringTable调优
- 添加桶的个数：StringTable的数据结构实现是哈希表，调优即对哈希表的桶的个数的调整，桶的个数越多时，哈希表查找更快。使用：-XX:StringTableSize=xxxx调整桶的个数。
- 使用intern方法：可以通过intern方法减少重复入池

直接内存(DirectBuffer)

特征：
- 属于操作系统，常见于NIO操作时，用于数据缓冲区
- 分配回收成本较高，但读写性能高
- 不受JVM内存回收管理
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率，如下图两种文件读取方式的流程：

正常流程：

使用直接内存：

申请与释放原理

直接内存的申请使用ByteBuffer申请，回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放

相关代码如下：

//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);

//allocateDirect的实现
public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer类(在此类中用unsafe.allocateMemory申请内存)：

DirectByteBuffer(int cap) {   // package-private
   
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        //申请内存
        base = unsafe.allocateMemory(size); 
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // Round up to page boundary
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); 
    att = null;
}

这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是DirectByteBuffer）被回收以后，就会调用Cleaner的clean方法,通过unsafe.freeMemory，来清除直接内存中占用的内存。

public void clean() {
    if (remove(this)) {
        try {
            //调用run方法
            this.thunk.run(); 
        } catch (final Throwable var2) {
            AccessController.doPrivileged(new PrivilegedAction<Void>() {
                public Void run() {
                    if (System.err != null) {
                        (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                    }

                    System.exit(1);
                    return null;
                }
            });
        }
        
//对应对象的run方法
public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    //释放直接内存中占用的内存
    unsafe.freeMemory(address); 
    address = 0;
    Bits.unreserveMemory(size, capacity);
}

直接内存的回收机制总结
- 使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法；
- ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存。