JVM内存结构 – 小飞侠

整体架构

在这里插入图片描述

程序计数器

作用

用于保存JVM中下一条所要执行的指令的地址(使用的是设备中的寄存器)

特点

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

虚拟机栈

定义

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

演示

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

在这里插入图片描述

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

问题辨析

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

内存溢出

Java.lang.stackOverflowError

栈内存溢出

发生原因

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

线程运行诊断

CPU占用过高

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

本地方法栈

说明

一些带有

native

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

Object.hashCode()
Object.clone()

堆

定义

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

特点

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

堆内存溢出

java.lang.OutofMemoryError ：java heap space.

堆内存溢出

堆内存诊断

jps

查看当前系统中有哪些Java进程

jmap

jmap -heap 进程ID , 查看堆内存的占用情况

jconsole

jconsole , 图形界面的，多功能的监测工具，可以连续监测

jvisualvm

jvisualvm , 图形界面的，多功能的监测工具，可以连续监测,并且可以将堆Dump下来进行分析

方法区

结构

在这里插入图片描述

内存溢出

JDK1.8以前会导致永久代（PermGen）内存溢出
JDK1.8以后会导致元空间（Metaspace）内存溢出

常量池

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

通过反编译来查看类的信息

获取对应类的.class文件
- 在.java的目录下的控制台输入
javac .\HelloWord.java
- 在控制台输入 javap -v .class的绝对路径
javap -v .\HelloWord.class
然后能在控制台看到反编译以后类的信息了
- 类的基本信息
- 常量池
- 虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）

常量池与串池的关系

串池StringTable

特征

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

用来放字符串对象且里面的

元素不重复

public class StringTable {
    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

当执行到

0: ldc

时，会把常量池中的符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构不可扩容）
当执行到

3: ldc

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

6: ldc

时，会把常量池中的符号 ab 变为 “ab” 字符串对象，并放入串池中
最终串池（StringTable）中数据如 [“a”, “b”, “ab”]

注意：

字符串对象的创建都是

懒惰的

，只有当运行到那一行字符串且在串池中不存在的时候（如

0: ldc

）时，该字符串才会被创建并放入串池中。

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

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

反编译后的结果

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
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
29: return

通过观察反编译后的源码后发现通过拼接的方式来创建字符串的过程实际上是：

StringBuilder().append(“a”).append(“b”).toString()

比较ab与ab2是否相等

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

最后的toString方法的返回值是一个

新的字符串

，但字符串的值和拼接的字符串一致，但是两个不同的字符串，

一个存在于串池之中，一个存在于堆内存之中

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

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

反编译后的结果

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: ldc           #4                  // String ab
11: astore        4
13: return

使用

拼接字符串常量

的方法来创建新的字符串时，因为内容是常量，

javac在编译期会进行优化

，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接

从串池中获取值

，所以进行的操作和 ab = “ab” 一致。
使用拼接字符串变量的方法来创建新的字符串时，因为

内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建

intern方法

JDK1.8

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

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

返回串池中的字符串对象

注意

：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象。

例1

public class StringTable {
    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 StringTable {
    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);
    }
}

JDK1.6

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

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

返回串池中的字符串对象

注意

：此时无论调用intern方法成功与否，

串池中的字符串对象和堆内存中的字符串对象都不是同一个对象

StringTable 垃圾回收

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

StringTable调优

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

-XX:StringTableSize=xxxx
考虑是否需要将字符串对象入池，可以通过intern方法减少重复入池

直接内存

属于操作系统，常见于NIO操作时，用于

数据缓冲区
分配回收成本较高，但读写性能高
不受JVM内存回收管理

文件读写流程

在这里插入图片描述

使用了直接内存（DirectBuffer）

在这里插入图片描述

直接内存是操作系统和Java代码

都可以访问的一块区域

，无需将代码从系统内存复制到Java堆内存，从而提高了效率

释放原理

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

通过

//通过ByteBuffer申请1G的直接内存
int _1G = 1024 * 1024 * 1024;
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1G);

申请直接内存，但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));
    att = null;

}

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

public void clean() {
    if (remove(this)) {
        try {
            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来释放内存

原文链接：https://blog.csdn.net/qq_42091436/article/details/127380840

整体架构

程序计数器

作用

特点

虚拟机栈

定义

演示

问题辨析

内存溢出

发生原因

线程运行诊断

本地方法栈

说明

堆

定义

特点

堆内存溢出

堆内存诊断

方法区

结构

内存溢出

常量池

通过反编译来查看类的信息

常量池与串池的关系

串池StringTable

intern方法

JDK1.8

JDK1.6

StringTable 垃圾回收

StringTable调优

直接内存

文件读写流程

使用了直接内存（DirectBuffer）

释放原理

allocateDirect的实现

直接内存的回收机制总结

你可能也喜欢