JVM--内存结构

一、什么是JVM

定义

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

好处

• 一次编写，到处运行
• 自动内存管理，垃圾回收机制
• 数组下标越界检查
• 多态 （虚方法表机制实现）

比较

JVM JRE JDK的区别

截屏2021-09-18 20.57.24.png

二、内存结构

整体架构

截屏2021-09-18 21.00.52.png

分成3大块：类加载器、JVM内存结构、执行引擎。

• 从java源代码编译成java class，通过类加载器加载到JVM内存中去运行；
• 类放在方法区，创建的实例对象放在Heap（堆）中，堆里的对象在调用方法时，又会用到虚拟机栈（Stack）、程序计数器（PC）、本地方法栈（Native）；
• 方法执行时，每行代码是由执行引擎中的解释器逐行执行，一些热点代码会由JIT即时编译器编译优化，GC会对不再引用的对象进行回收，一些与操作系统打交道的就需要调用操作系统提供的本地方法接口。

1、程序计数器

作用

用于保存JVM中下一条所要执行的指令的地址

特点

• 线程私有
  -- CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
  -- 程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
• 不会内存溢出

2、虚拟机栈

定义

• 每个线程运行需要的内存空间，称为虚拟机栈
• 每个栈由多个栈帧（Frame）组成，对应着每次调用方法时所占用的内存
• 每个线程只能有一个活动栈帧，对应着当前正在执行的方法

演示

public class Main {
    public static void main(String[] args) {
        method1();
    }
    private static void method1() {
        method2(1, 2);
    }
    private static int method2(int a, int b) {
        int c = a + b;
        return c;
    }
}

截屏2021-09-18 21.16.57.png

在控制台中可以看到，主类中的方法在进入虚拟机栈的时候，符合栈的特点

问题辨析

• 垃圾回收是否涉及栈内存？
  -- 不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
• 栈内存的分配越大越好吗？
  -- 不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
• 方法内的局部变量是否是线程安全的？
  -- 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
  -- 如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题

内存溢出

Java.lang.stackOverflowError 栈内存溢出
使用 -Xss256k 指定栈内存大小

发生原因

• 虚拟机栈中，栈帧过多（无限递归）
• 每个栈帧所占用过大

线程运行诊断

案例一：cpu 占用过多

• Linux环境下运行某些程序的时候，可能导致CPU的占用过高，这时需要定位占用CPU过高的线程
  1、确定哪个进程占用CPU过高：
   命令：top
  2、确定哪个线程占用CPU过高：
   命令：ps H -eo pid, tid, %cpu | grep 进程ID
  3、定位具体代码：
   命令：jstack 进程id
   通过查看进程中的线程的nid，刚才ps命令看到的tid来对比定位，注意jstack查找出的线程id是16进制的，需要转换。
  4、jstack 进程id 工具还可以定位死锁信息。

3、本地方法栈

一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法

4、堆

定义

通过new关键字创建的对象都会被放在堆内存

特点

• 所有线程共享，堆内存中的对象都需要考虑线程安全问题
• 有垃圾回收机制

堆内存溢出

java.lang.OutofMemoryError ：java heap space. 堆内存溢出
可以使用 -Xmx8m 来指定堆内存大小。
调试程序时怀疑是堆内存溢出，可以尝试把堆内存调小一点试试。

堆内存诊断

• jps 工具
  -- 查看当前系统中有哪些 java 进程
• jmap 工具
  -- 查看堆内存占用情况: jmap - heap 进程id

        System.out.println("1");
        Thread.sleep(30000);

        System.out.println("2");
        byte[] bytes = new byte[1024 * 1024 *10];
        Thread.sleep(10000);

        System.out.println(3);
        bytes = null;
        System.gc();
        Thread.sleep(10000);

-- java11环境：jhsdb jmap --heap --pid 922

• jconsole 工具
  -- 图形界面的，多功能的监测工具，可以连续监测
• jvirsualvm 工具
  --监视--》堆dump （可dump下来当前时刻的堆信息）
  ----〉检查--查找（指定大小堆）---》定位具体哪个对象占用空间比较大

5、方法区

定义

JVM线程之间共享的方法区域。它存储每个类的结构数据，例如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括特殊方法，用于类和实例初始化以及接口初始化方法区域是在虚拟机启动时创建的。

• 实现：

永久代（1.8之前）：存储包括类信息、常量、字符串常量、类静态变量、即时编译器编译后的代码等数据。

元空间（1.8以后）：使用的是物理内存，元空间是方法区的在 HotSpot JVM 中的实现，方法区主要用于存储类信息、常量池、方法数据、方法代码、符号引用等。元空间的本质和永久代类似，都是对 JVM 规范中方法区的实现。

方法区内存溢出

• 1.8 之前会导致永久代内存溢出
  -- 使用 -XX:MaxPermSize=8m 指定永久代内存大小
• 1.8 之后会导致元空间内存溢出
  -- 使用 -XX:MaxMetaspaceSize=8m 指定元空间大小

常量池

二进制字节码的组成：类的基本信息、常量池、类的方法定义（包含了虚拟机指令）

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

使用 javap -v Hello.class 命令反编译查看结果:

截屏2021-09-20 11.05.02.png

运行时常量池

• 常量池
  -- 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
• 运行时常量池
  -- 常量池是.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字符串

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 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构 不可扩容）

当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中

当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中

最终StringTable [“a”, “b”, “ab”]

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

• 使用拼接字符串变量对象创建字符串的过程：

public class StringTableStudy {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String ab = "ab";
        //拼接字符串对象来创建新的字符串
        String ab2 = a+b; 
    }
}

反编译后的结果：

     Code:
      stack=2, locals=5, 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."":()V
        16: aload_1
        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/Str
ing;
        27: astore        4
        29: return

通过变量拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()

最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中

String ab = "ab";
String ab2 = a+b;
//结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中
System.out.println(ab == ab2);

• 使用拼接字符串常量对象的方法创建字符串：

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";
    }
}

反编译后的结果：

      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."":()V
        16: aload_1
        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/Str
ing;
        27: astore        4
        //ab3初始化时直接从串池中获取字符串
        29: ldc           #4                  // String ab
        31: astore        5
        33: return

• 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
• 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建

intern方法 (jkd1.8)

一般，只有字面量才能放入串池中。

但，调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

• 如果串池中没有该字符串对象，则放入成功
• 如果有该字符串对象，则放入失败
  无论放入是否成功，都会返回串池中的字符串对象

注意：此时如果调用intern方法成功（放入串池成功），堆内存与串池中的字符串对象是同一个对象；如果失败（放入串池失败，也就是串池中已经存在），则不是同一个对象
例1

public class Main {
    public static void main(String[] args) {
        //"a" "b" 被放入串池中，str则存在于堆内存之中
        String str = new String("a") + new String("b");
        //调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象
        String st2 = str.intern();
        //给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回
        String str3 = "ab";
        //因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true
        System.out.println(str == st2);
        System.out.println(str == str3);
    }
}

例2

public class Main {
    public static void main(String[] args) {
        //此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中
        String str3 = "ab";
        //"a" "b" 被放入串池中，str则存在于堆内存之中
        String str = new String("a") + new String("b");
        //此时因为在创建str3时，"ab"已存在与串池中，所以放入失败，但是会返回串池中的"ab"
        String str2 = str.intern();
        //false
        System.out.println(str == str2);
        //false
        System.out.println(str == str3);
        //true
        System.out.println(str2 == str3);
    }
}

intern方法 (jkd1.6)

调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

• 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
• 如果有该字符串对象，则放入失败
  无论放入是否成功，都会返回串池中的字符串对象

注意：此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象

StringTable 的位置

jdk1.6 StringTable 位置是在永久代中，1.8 StringTable 位置是在堆中。

永久代中gc是full gc，堆内存中gc是minorr gc。

/**
 * 演示 StringTable 位置
 * 在jdk8下设置 -Xmx10m -XX:-UseGCOverheadLimit
 * 在jdk6下设置 -XX:MaxPermSize=10m
 */
public class Demo1_6 {

    public static void main(String[] args) throws InterruptedException {
        List list = new ArrayList();
        int i = 0;
        try {
            for (int j = 0; j < 260000; j++) {
                list.add(String.valueOf(j).intern());
                I++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}

通过不同版本jdk的StringTable内存不足时报错信息：

jdk1.6：java.lang.OutOfMemoryError：PermGen space
jdk1.8：java.lang.OutOfMemoryError：GC overhead limit exceeded
或者：java.lang.OutOfMemoryError：Java heap space

StringTable 垃圾回收

StringTable在内存紧张时，会发生垃圾回收

-Xmx10m 指定堆内存大小
-XX:+PrintStringTableStatistics 打印字符串常量池信息
-XX:+PrintGCDetails
-verbose:gc 打印 gc 的次数，耗费时间等信息

【代码演示】

/**
 * 演示 StringTable 垃圾回收
 * -Xmx10m -XX:+PrintStringTableStatistics -XX:+PrintGCDetails -verbose:gc
 */
public class Demo1_7 {
    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        try {
            for (int j = 0; j < 100000; j++) { // j=100, j=10000
                String.valueOf(j).intern();
                I++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            System.out.println(i);
        }
    }
}

分别看往StringTable里添加100和10000个字符串常量看串池常量数增加和gc现象。

StringTable调优

• 因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间

-XX:StringTableSize=桶个数（最少设置为 1009 以上）

/**
 * 演示串池大小对性能的影响
 * -Xms500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=1009
 */
public class Demo1_24 {
    public static void main(String[] args) throws IOException {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
            String line = null;
            long start = System.nanoTime();
            while (true) {
                line = reader.readLine();
                if (line == null) {
                    break;
                }
                line.intern();
            }
            System.out.println("cost:" + (System.nanoTime() - start) / 1000000);
        }
    }
}

• 考虑是否需要将字符串对象入池
  可以通过 intern 方法减少重复入池

/**
 * 演示 intern 减少内存占用
 * -XX:StringTableSize=200000 -XX:+PrintStringTableStatistics
 * -Xsx500m -Xmx500m -XX:+PrintStringTableStatistics -XX:StringTableSize=200000
 */
public class Demo1_25 {
    public static void main(String[] args) throws IOException {
        List address = new ArrayList<>();
        System.in.read();
        for (int i = 0; i < 10; i++) {
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("linux.words"), "utf-8"))) {
                String line = null;
                long start = System.nanoTime();
                while (true) {
                    line = reader.readLine();
                    if(line == null) {
                        break;
                    }
                    address.add(line.intern());
                }
                System.out.println("cost:" +(System.nanoTime()-start)/1000000);
            }
        }
        System.in.read();
    }
}

6、直接内存

• 属于操作系统，常见于NIO操作时，用于数据缓冲区 --ByteBuffer
• 分配回收成本较高，但读写性能高
• 不受JVM内存回收管理

文件读写流程:

使用了DirectBuffer:

直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率

释放原理

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

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

申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？

allocateDirect的实现

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer类

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;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象
    att = null;
}

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

public void clean() {
       if (remove(this)) {
           try {
               this.thunk.run(); //调用run方法
           } catch (final Throwable var2) {
               AccessController.doPrivileged(new PrivilegedAction() {
                   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来释放内存。