投稿
  1. 首页
  2. 随笔

JVM（一）内存结构

code • 2022-4-12 • 随笔 • 阅读 174

JVM（一）内存结构,第1张

JVM（一）内存结构

今日开篇

什么是JVM 定义

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

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

学习JVM的作用

jvm的讲解以hotspot为准

整体架构

JVM内存结构 1、程序计数器

二进制字节码、jvm指令——需要经过解释器成为机器码，再给cpu执行

作用：是记住下一条jvm指令的执行地址

上图的数字就是地址，放入程序计数器中，然后解释器来读

寄存器来当作程序计数器

特点

线程私有

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

不会存在内存溢出

2、虚拟机栈

  • 每个线程运行需要的内存空间，称谓虚拟机栈

  • 每个栈由多个栈帧组成，对应着每次调用方法时所占用的内存

  • 每个线程只能有一个活动栈帧，对应着当前正在执行的方法

栈帧就是每个方法运行需要的内存

演示

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;

	}

}

不断压栈和出栈

问题辨析
  • 垃圾回收是否涉及栈内存？

    • 不需要。


      因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被d出栈。


      所以无需通过垃圾回收机制去回收内存。


  • 栈内存的分配越大越好吗？
    • 不是。


      因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。


  • 方法内的局部变量是否是线程安全的？
    • 如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
    • 如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题

栈是线程私有的，不会有线程不安全问题

线程安全

线程不安全

多个线程公用对象sb，返回值sb是对象可以被主线程修改也是不安全，基本类型不会出现返回值问题

是否逃离了方法的作用范围

栈内存溢出

Java.lang.stackOverflowError 栈内存溢出

递归调用，需要正确的递归边界

发生原因
  • 虚拟机栈中，栈帧过多（无限递归）
  • 每个栈帧所占用过大
线程运行诊断
  • Linux环境下运行某些程序的时候，可能导致CPU的占用过高，这时需要定位占用CPU过高的线程

    • top命令，查看是哪个进程占用CPU过高
    • ps H -eo pid, tid（线程id）, %cpu | grep 刚才通过top查到的进程号 通过ps命令进一步查看是哪个线程占用CPU过高
    • jstack 进程id 通过查看进程中的线程的nid，刚才通过ps命令看到的tid来对比定位，注意jstack查找出的线程id是16进制的，需要转换

死锁的例子

3、本地方法栈

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


java调用c语言编写的方法---本地方法篇之java中的native关键字

c写的代码，用java调用

4、堆

heap

定义

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

特点

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

java.lang.OutofMemoryError ：java heap space. 堆内存溢出

堆内存诊断

jconsole

案例：垃圾回收后，内存占用依然很高

jvirsalvm

某个容器一直使用，没有回收

5、方法区

p46页

方法区与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类型信息、常量、静态变量

内存溢出
  • 1.8以前会导致永久代内存溢出
  • 1.8以后会导致元空间内存溢出

元空间内存溢出

永久代内存溢出

运行时常量池

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

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

  • 获得对应类的.class文件

    • 在JDK对应的bin目录下运行cmd，也可以在IDEA控制台输入

  • 输入 javac 对应类的绝对路径
F:\JAVA\JDK8.0\bin>javac F:\Thread_study\src\com\nyima\JVM\day01\Main.javaCopy

输入完成后，对应的目录下就会出现类的.class文件

  • 在控制台输入 javap -v 类的绝对路径

    javap -v F:\Thread_study\src\com\nyima\JVM\day01\Main.classCopy

  • 然后能在控制台看到反编译以后类的信息了

  • 类的基本信息

  • 常量池

虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）

运行时常量池

  • 常量池

    • 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
  • 运行时常量池
    • 常量池是.class文件中的，当该*类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址
StringTable

常量池与串池的关系

串池StringTable在运行常量池中

特征

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

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

1、变量拼接

常量池中的信息，都会被加载到运行时常量池中，但这是a b ab 仅是常量池中的符号，还没有成为java字符串

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

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

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

最终StringTable [“a”, “b”, “ab”]是hashtable结构不能扩容

注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 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."<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/Str

ing;

        27: astore        4

        29: return

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

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

String ab = "ab";

String ab2 = a+b;

//结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中

System.out.println(ab == ab2);

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

	}

}

反编译后的结果

 	  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

        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来创建

串池，遇见一个 没见过的字符串则放入串池

3、intern方法 1.8

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

  • 如果串池中没有该字符串对象，则放入成功
  • 如果有该字符串对象，则放入失败

无论放入是否成功，都会返回串池中的字符串对象

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

动态拼接的仅在堆中，并不在串池中

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

	}

}

str对象也会放入串池中，如果已经有则入队失败

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方法 1.6

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

  • 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
  • 如果有该字符串对象，则放入失败

无论放入是否成功，都会返回串池中的字符串对象

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

StringTable的位置

1.6永久代内存触发时间迟，现在都放在堆中，1.7之后都在堆中提高效率

jvm垃圾回收

如果98%的时间花在垃圾回收上，但是只回收2%的堆空间，就会报一个错误

就可以重新出现Java heap space堆内存溢出

StringTable的垃圾回收

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

StringTable调优

底层是哈希表

48万个单词放在20万个桶中，所以一个桶2个链表长度，速度就快

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

  • 考虑是否需要将字符串对象入池

    可以通过intern方法减少重复入池

​将重复字符串入池，来减少字符串个数节约堆内存的使用

6、直接内存
  • 属于 *** 作系统，常见于NIO *** 作时，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受JVM内存回收管理
传统IO与NIO性能比较

NIO效率更高

读取俩次效率低，先读取系统在读取给java

使用了DirectBuffer

少了一次读取 *** 作，效率提高

注意NIO的知识也要补充

直接内存是 *** 作系统和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实现类，里面有base = unsafe.allocateMemory(size); //申请内存

cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象

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

分配和回收原理
  • 使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
  • ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。


    一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存

直接内存用unsafe手动删除

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/589536.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-12
下一篇 2022-04-12

发表评论

登录后才能评论

评论列表（0条）

保存