一、什么是JVM

定义

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

好处

  • 一次编写，到处运行
  • 自动内存管理，垃圾回收机制

  • 数组下标越界检查

    比较

    JVM JRE JDK的区别
    image.png

    二、内存结构

    整体架构

    image.png

    1.程序计数器

    作用

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

    特点

  • 线程私有

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

  • 不会内存溢出

    2.虚拟机栈

    定义

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

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

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

    演示

    代码

    1. public class Main {
    2.   public static void main(String[] args) {
    3.       method1();
    4.   }
    6.   private static void method1() {
    7.       method2(1, 2);
    8.   }
    10.   private static int method2(int a, int b) {
    11.       int c = a + b;
    12.       return c;
    13.   }
    14. }

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

    问题

  • 垃圾回收是否涉及栈内存？

不需要，引入方法执行完毕，会弹出虚拟机栈

  • 栈的内存分配的越大越好么？

栈的内存不是分配的越大越好，因为栈的内存分配的越大，它线程的个数就会相应减少，并发度下降。

  • 方法内的局部变量是否线程安全？

方法内的局部变量是线程安全的，因为方法是线程调用的，归属于某个特定的线程，对其他线程不可见，所以是线程安全的。

内存溢出

Java.lang.stackOverflowError 栈内存溢出

发生原因

  • 虚拟机栈帧过多（无限递归）

  • 每个栈帧所占内存过多

    3.本地方法栈

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

    4.堆

    定义

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

    特点

  • 所以线程共享，堆内存的对象都需要考虑线程的安全性

  • 有垃圾回收机制

    堆内存溢出

    Java.lang.OutofMermoryError:java.heap.space 堆内存溢出

    5.方法区

    结构

    image.png

    内存溢出

  • 1.8以前会导致永久代内存溢出

  • 1.8以后会导致元空间内存溢出

    常量池

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

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

  • 获得对应类的.class文件

image.png

  • 常量池

image.png

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

运行时常量池

  • 常量池
    • 就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息

  • 运行时常量池

    常量池是.class文件中的，当该类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

    常量池与串池的关系

    串池StringTable

    特征

  • 常量池中的字符串仅是符号，只有在被用到的时候才转换成对象

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

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

  1. public class StringTableStudy {
  2.     public static void main(String[] args) {
  3.         String a = "a"; 
  4.         String b = "b";
  5.         String ab = "ab";
  6.     }
  7. }

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

  1. 0: ldc           #2                  // String a
  2. 2: astore_1
  3. 3: ldc           #3                  // String b
  4. 5: astore_2
  5. 6: ldc           #4                  // String ab
  6. 8: astore_3
  7. 9: return

当执行到ldc#2时，会把符号a变为‘a’字符串对象，并放入串池中hashtable结构，不可扩容)
当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中
当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中
最终StringTable [“a”, “b”, “ab”]
注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中。
使用拼接字符串变量对象创建字符串的过程

  1. public class StringTableStudy {
  2.     public static void main(String[] args) {
  3.         String a = "a";
  4.         String b = "b";
  5.         String ab = "ab";
  6.         //拼接字符串对象来创建新的字符串
  7.         String ab2 = a+b; 
  8.     }
  9. }

反编译后的结果 

  1.      Code:
  2.       stack=2, locals=5, args_size=1
  3.          0: ldc           #2                  // String a
  4.          2: astore_1
  5.          3: ldc           #3                  // String b
  6.          5: astore_2
  7.          6: ldc           #4                  // String ab
  8.          8: astore_3
  9.          9: new           #5                  // class java/lang/StringBuilder
  10.         12: dup
  11.         13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
  12.         16: aload_1
  13.         17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
  14. ;)Ljava/lang/StringBuilder;
  15.         20: aload_2
  16.         21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
  17. ;)Ljava/lang/StringBuilder;
  18.         24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
  19. ing;
  20.         27: astore        4
  21.         29: return

通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()
最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中

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

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

  1. public class StringTableStudy {
  2.     public static void main(String[] args) {
  3.         String a = "a";
  4.         String b = "b";
  5.         String ab = "ab";
  6.         String ab2 = a+b;
  7.         //使用拼接字符串的方法创建字符串
  8.         String ab3 = "a" + "b";
  9.     }
  10. }

反编译后的结果 

  1.        Code:
  2.       stack=2, locals=6, args_size=1
  3.          0: ldc           #2                  // String a
  4.          2: astore_1
  5.          3: ldc           #3                  // String b
  6.          5: astore_2
  7.          6: ldc           #4                  // String ab
  8.          8: astore_3
  9.          9: new           #5                  // class java/lang/StringBuilder
  10.         12: dup
  11.         13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
  12.         16: aload_1
  13.         17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
  14. ;)Ljava/lang/StringBuilder;
  15.         20: aload_2
  16.         21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
  17. ;)Ljava/lang/StringBuilder;
  18.         24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
  19. ing;
  20.         27: astore        4
  21.         //ab3初始化时直接从串池中获取字符串
  22.         29: ldc           #4                  // String ab
  23.         31: astore        5
  24.         33: return
  • 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
  • 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建

    intern方法 1.8

    调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中
  1. 如果串池中没有该字符串对象，则放入成功
  2. 如果有该字符串对象，则放入失败

无论放入是否成功，都会返回串池中的字符串对象
注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象
例1

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

例2

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

intern方法 1.6

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

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

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