JVM系列2：内存结构

最新推荐文章于 2024-07-15 18:45:28 发布
最新推荐文章于 2024-07-15 18:45:28 发布
阅读量197 收藏
点赞数
分类专栏： JVM 文章标签： jvm java 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43298198/article/details/105772830
版权

内存结构

  1. 程序计数器
  2. 虚拟机栈
  3. 本地方法栈
  4. 堆
  5. 方法区
  6. 直接内存

1. 程序计数器

在这里插入图片描述

1.1 定义

Program Counter Register 程序计数器（寄存器）

  • 作用，是记住下一条jvm指令的执行地址
  • 特点
    • 是线程私有的
    • 不会存在内存溢出

1.2 作用

 //jvm指令
0: getstatic     #20                 // PrintStream out = System.out;
 3: astore_1                          // --
 4: aload_1                           // out.println(1);
 5: iconst_1                          // --
 6: invokevirtual #26                 // --
 9: aload_1                           // out.println(2);
10: iconst_2                          // --
11: invokevirtual #26                 // --
14: aload_1                           // out.println(3);
15: iconst_3                          // --
16: invokevirtual #26                 // --
19: aload_1                           // out.println(4);
20: iconst_4                          // --
21: invokevirtual #26                 // --
24: aload_1                           // out.println(5);
25: iconst_5                          // --
26: invokevirtual #26                 // --
29: return

执行顺序：jvm指令->解释器->机器码->CPU执行

2. 虚拟机栈

在这里插入图片描述

2.1 定义

Java Virtual Machine Stacks （Java 虚拟机栈）

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

问题辨析

  1. 垃圾回收是否涉及栈内存？ 不需要，栈帧内存在每次方法调用结束后会被函数栈自动回收

  2. 栈内存分配越大越好吗？不是，栈内存变大只是增大递归次数，但是却减少了线程数。例如，一个栈内存大小时为1M,物理内存有500M，就是500个线程，若占内存大小变为2M，线程数变为250个

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

    • 如果方法内局部变量没有逃离方法的作用访问，它是线程安全的

      /**
 * 局部变量的线程安全问题
 */
public class Demo1_18 {

    // 多个线程同时执行此方法 ,x是线程安全的，因为x是私有的变量
    static void m1() {
        int x = 0;
        for (int i = 0; i < 5000; i++) {
            x++;
        }
        System.out.println(x);
    }
}

    • 如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

      public class Demo1_17 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append(4);
        sb.append(5);
        sb.append(6);
        new Thread(()->{
            m2(sb);
        }).start();
    }

    public static void m1() { //线程安全的，sb是私有的
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());
    }

    public static void m2(StringBuilder sb) {
        sb.append(1);
        sb.append(2);
        sb.append(3);
        System.out.println(sb.toString());//线程是不安全的，存在变量的引用
    }

    public static StringBuilder m3() {
        StringBuilder sb = new StringBuilder();
        sb.append(1);
        sb.append(2);
        sb.append(3);
        return sb;//线程不安全，存在返回值，逃离方法的作用范围
    }
}

2.2 栈内存溢出

  • 栈帧过多导致栈内存溢出

    常见场景：递归

  • 栈帧过大导致栈内存溢出（很少见）

    /**
 * json 数据转换
 */
public class Demo1_19 {

    public static void main(String[] args) throws JsonProcessingException {
        Dept d = new Dept();
        d.setName("Market");

        Emp e1 = new Emp();
        e1.setName("zhang");
        e1.setDept(d);

        Emp e2 = new Emp();
        e2.setName("li");
        e2.setDept(d);

        d.setEmps(Arrays.asList(e1, e2));

        // { name: 'Market', emps: [{ name:'zhang', dept:{ name:'', emps: [ {}]} },] }
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(d));
    }
}

class Emp {
    private String name;
    @JsonIgnore //如果不加这个注解就会导致栈溢出
    private Dept dept;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }
}
class Dept {
    private String name;
    private List<Emp> emps;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Emp> getEmps() {
        return emps;
    }

    public void setEmps(List<Emp> emps) {
        this.emps = emps;
    }

2.3 线程运行诊断

案例1： cpu 占用过多

定位

  1. 使用nohup在后台运行一个java代码 nohup java Demo1_16 &
    • 用top定位哪个进程对cpu的占用过高
    • ps H -eo pid,tid,%cpu | grep 进程id （用ps命令进一步定位是哪个线程引起的cpu占用过高）
    • jstack 进程id
      • 可以根据线程id 找到有问题的线程，进一步定位到问题代码的源码行号

案例2：程序运行很长时间没有结果

死锁案例：使用jstack pid 查看

class A{};
class B{};
public class Demo1_3 {
    static A a = new A();
    static B b = new B();


    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            synchronized (a) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b) {
                    System.out.println("我获得了 a 和 b");
                }
            }
        }).start();
        Thread.sleep(1000);
        new Thread(()->{
            synchronized (b) {
                synchronized (a) {
                    System.out.println("我获得了 a 和 b");
                }
            }
        }).start();
    }

}

3. 本地方法栈

在这里插入图片描述

当程序在调用一些底层的方法时会用到本地方法栈。

4. 堆

在这里插入图片描述

4.1 定义

Heap 堆

  • 通过 new 关键字，创建对象都会使用堆内存

特点

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

4.2 堆内存溢出

/**
 * 演示堆内存溢出 java.lang.OutOfMemoryError: Java heap space
 * 当我们在进行程序调试的时候可以修改我们的堆空间的大小，来查看空间是否存在溢出现象
 * -Xmx8m
 */
public class Demo1_5 {

    public static void main(String[] args) {
        int i = 0;
        try {
            List<String> list = new ArrayList<>();
            String a = "hello";
            while (true) {
                list.add(a); // hello, hellohello, hellohellohellohello ...
                a = a + a;  // hellohellohellohello
                i++;
            }
        } catch (Throwable e) {
            e.printStackTrace();
            System.out.println(i);
        }
    }
}

4.3 堆内存诊断

  1. jps 工具

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

      F:\视频-解密JVM\资料 解密JVM\代码\jvm\jvm>jps
13028 Jps
13060
11080 Demo1_4
2984 RemoteMavenServer
2012 Launcher

  2. jmap 工具

    • 查看堆内存占用情况 jmap - heap 进程id

      F:\视频-解密JVM\资料 解密JVM\代码\jvm\jvm>jmap -heap 2944
Attaching to process ID 2944, please wait...
Debugger attached successfully.
Server compiler detected.
JVM version is 25.131-b11

using thread-local object allocation.
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 2095054848 (1998.0MB)
   NewSize                  = 44040192 (42.0MB)
   MaxNewSize               = 698351616 (666.0MB)
   OldSize                  = 88080384 (84.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 33554432 (32.0MB)
   used     = 13878224 (13.235305786132812MB)
   free     = 19676208 (18.764694213867188MB)
   41.36033058166504% used
From Space:
   capacity = 5242880 (5.0MB)
   used     = 0 (0.0MB)
   free     = 5242880 (5.0MB)
   0.0% used
To Space:
   capacity = 5242880 (5.0MB)
   used     = 0 (0.0MB)
   free     = 5242880 (5.0MB)
   0.0% used
PS Old Generation
   capacity = 88080384 (84.0MB)
   used     = 0 (0.0MB)
   free     = 88080384 (84.0MB)
   0.0% used

1794 interned Strings occupying 180672 bytes

  3. jconsole 工具

    • 图形界面的，多功能的监测工具，可以连续监测
      在这里插入图片描述

4.使用jvisualvm工具进行内存诊断

案例

  • 垃圾回收后，内存占用仍然很高

    /**
 * 演示查看对象个数 堆转储 dump,然后分析堆中对象的占用情况
 */
public class Demo1_13 {

    public static void main(String[] args) throws InterruptedException {
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < 200; i++) {
            students.add(new Student());
//            Student student = new Student();
        }
        Thread.sleep(1000000000L);
    }
}
class Student {
    private byte[] big = new byte[1024*1024];
}

在这里插入图片描述

5. 方法区

在这里插入图片描述

5.1 定义

JVM规范-方法区定义

The Java Virtual Machine has a method area that is shared among all Java Virtual Machine threads. The method area is analogous to the storage area for compiled code of a conventional language or analogous to the “text” segment in an operating system process. It stores per-class structures such as the run-time constant pool, field and method data, and the code for methods and constructors, including the special methods (§2.9) used in class and instance initialization and interface initialization.

Java虚拟机有一个方法区域，在所有Java虚拟机线程之间共享。方法区域类似于常规语言编译代码的存储区域，或者类似于操作系统进程中的“文本”段。它存储每类结构，如运行时常量池、字段和方法数据，以及方法和构造函数的代码，包括在类和实例初始化以及接口初始化中使用的特殊方法（§2.9）。

The method area is created on virtual machine start-up. Although the method area is logically part of the heap, simple implementations may choose not to either garbage collect or compact it. This specification does not mandate the location of the method area or the policies used to manage compiled code. The method area may be of a fixed size or may be expanded as required by the computation and may be contracted if a larger method area becomes unnecessary. The memory for the method area does not need to be contiguous.

方法区域是在虚拟机启动时创建的。尽管方法区域在逻辑上是堆的一部分，但是简单的实现可以选择不垃圾收集或压缩它。此规范不强制指定用于管理已编译代码的方法区域或策略的位置。方法区域可以是固定大小的，或者可以根据计算的需要进行扩展，并且如果不需要更大的方法区域，则可以收缩。方法区域的内存不需要是连续的。

A Java Virtual Machine implementation may provide the programmer or the user control over the initial size of the method area, as well as, in the case of a varying-size method area, control over the maximum and minimum method area size.

Java虚拟机实现可以向程序员或用户提供对方法区域的初始大小的控制，并且，在大小不同的方法区域的情况下，还可以提供对最大和最小方法区域大小的控制。

The following exceptional condition is associated with the method area:

以下例外情况与方法区域相关：

If memory in the method area cannot be made available to satisfy an allocation request, the Java Virtual Machine throws an OutOfMemoryError.

如果方法区域中的内存无法满足分配请求，Java虚拟机将抛出OutOfMemoryError。

5.2 组成

在这里插入图片描述

在这里插入图片描述

这两个图片里的常量池应该写为运行时常量池。

5.3 方法区内存溢出

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

    * 演示永久代内存溢出  java.lang.OutOfMemoryError: PermGen space
* -XX:MaxPermSize=8m

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

    /**
 * 演示元空间内存溢出 java.lang.OutOfMemoryError: Metaspace
 * -XX:MaxMetaspaceSize=8m
 */
public class Demo1_8 extends ClassLoader { // 可以用来加载类的二进制字节码
    public static void main(String[] args) {
        int j = 0;
        try {
            Demo1_8 test = new Demo1_8();
            for (int i = 0; i < 10000; i++, j++) {
                // ClassWriter 作用是生成类的二进制字节码
                ClassWriter cw = new ClassWriter(0);
                // 版本号， public， 类名, 包名, 父类， 接口
                cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Class" + i, null, "java/lang/Object", null);
                // 返回 byte[]
                byte[] code = cw.toByteArray();
                // 执行了类的加载
                test.defineClass("Class" + i, code, 0, code.length); // Class 对象
            }
        } finally {
            System.out.println(j);
        }
    }
}

场景

  1. spring

  2. mybatis

    在这里面会用到动态代理，其就会记载很多的类

5.4 运行时常量池

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

    实例，一段简单的HelloWrold程序反编译后的结果

    // 二进制字节码（类基本信息，常量池，类方法定义，包含了虚拟机指令）
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

    F:\视频-解密JVM\资料 解密JVM\代码\jvm\jvm\src\cn\itcast\jvm\t5>javap -v HelloWorld.class
Classfile /F:/视频-解密JVM/资料 解密JVM/代码/jvm/jvm/src/cn/itcast/jvm/t5/HelloWorld.class
  Last modified 2020-4-26; size 442 bytes
  MD5 checksum 103606e24ec918e862312533fda15bbc
  Compiled from "HelloWorld.java"
public class cn.itcast.jvm.t5.HelloWorld
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
  ===================类的基本信息========================
Constant pool:
   #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #18            // hello world
   #4 = Methodref          #19.#20        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #21            // cn/itcast/jvm/t5/HelloWorld
   #6 = Class              #22            // java/lang/Object
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               SourceFile
  #14 = Utf8               HelloWorld.java
  #15 = NameAndType        #7:#8          // "<init>":()V
  #16 = Class              #23            // java/lang/System
  #17 = NameAndType        #24:#25        // out:Ljava/io/PrintStream;
  #18 = Utf8               hello world
  #19 = Class              #26            // java/io/PrintStream
  #20 = NameAndType        #27:#28        // println:(Ljava/lang/String;)V
  #21 = Utf8               cn/itcast/jvm/t5/HelloWorld
  #22 = Utf8               java/lang/Object
  #23 = Utf8               java/lang/System
  #24 = Utf8               out
  #25 = Utf8               Ljava/io/PrintStream;
  #26 = Utf8               java/io/PrintStream
  #27 = Utf8               println
  #28 = Utf8               (Ljava/lang/String;)V
  //类方法的定义
{
  public cn.itcast.jvm.t5.HelloWorld();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 4: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         //jvm的指令
         0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #3                  // String hello world
         5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 6: 0
        line 7: 8
}
SourceFile: "HelloWorld.java"

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

5.5 StringTable和常量池的关系

将下列代码进行反编译后查看结果

F:\视频-解密JVM\资料 解密JVM\代码\jvm\jvm\src\cn\itcast\jvm\t1\stringtable>javap -v Demo1_22.class
Classfile /F:/视频-解密JVM/资料 解密JVM/代码/jvm/jvm/src/cn/itcast/jvm/t1/stringtable/Demo1_22.class
  Last modified 2020-4-26; size 776 bytes
  MD5 checksum 5a4bdb3760a8a1b90340650b6651d07f
  Compiled from "Demo1_22.java"
public class cn.itcast.jvm.t1.stringtable.Demo1_22
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #12.#25        // java/lang/Object."<init>":()V
   #2 = String             #26            // a
   #3 = String             #27            // b
   #4 = String             #28            // ab
   #5 = Class              #29            // java/lang/StringBuilder
   #6 = Methodref          #5.#25         // java/lang/StringBuilder."<init>":()V
   #7 = Methodref          #5.#30         // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   #8 = Methodref          #5.#31         // java/lang/StringBuilder.toString:()Ljava/lang/String;
   #9 = Fieldref           #32.#33        // java/lang/System.out:Ljava/io/PrintStream;
  #10 = Methodref          #34.#35        // java/io/PrintStream.println:(Z)V
  #11 = Class              #36            // cn/itcast/jvm/t1/stringtable/Demo1_22
  #12 = Class              #37            // java/lang/Object
  #13 = Utf8               <init>
  #14 = Utf8               ()V
  #15 = Utf8               Code
  #16 = Utf8               LineNumberTable
  #17 = Utf8               main
  #18 = Utf8               ([Ljava/lang/String;)V
  #19 = Utf8               StackMapTable
  #20 = Class              #38            // "[Ljava/lang/String;"
  #21 = Class              #39            // java/lang/String
  #22 = Class              #40            // java/io/PrintStream
  #23 = Utf8               SourceFile
  #24 = Utf8               Demo1_22.java
  #25 = NameAndType        #13:#14        // "<init>":()V
  #26 = Utf8               a
  #27 = Utf8               b
  #28 = Utf8               ab
  #29 = Utf8               java/lang/StringBuilder
  #30 = NameAndType        #41:#42        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #31 = NameAndType        #43:#44        // toString:()Ljava/lang/String;
  #32 = Class              #45            // java/lang/System
  #33 = NameAndType        #46:#47        // out:Ljava/io/PrintStream;
  #34 = Class              #40            // java/io/PrintStream
  #35 = NameAndType        #48:#49        // println:(Z)V
  #36 = Utf8               cn/itcast/jvm/t1/stringtable/Demo1_22
  #37 = Utf8               java/lang/Object
  #38 = Utf8               [Ljava/lang/String;
  #39 = Utf8               java/lang/String
  #40 = Utf8               java/io/PrintStream
  #41 = Utf8               append
  #42 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #43 = Utf8               toString
  #44 = Utf8               ()Ljava/lang/String;
  #45 = Utf8               java/lang/System
  #46 = Utf8               out
  #47 = Utf8               Ljava/io/PrintStream;
  #48 = Utf8               println
  #49 = Utf8               (Z)V
{
  public cn.itcast.jvm.t1.stringtable.Demo1_22();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 4: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=3, 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/StringBuil
der;
        20: aload_2
        21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuil
der;
        24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        27: astore        4
        29: ldc           #4                  // String ab
        31: astore        5
        33: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
        36: aload_3
        37: aload         5
        39: if_acmpne     46
        42: iconst_1
        43: goto          47
        46: iconst_0
        47: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
        50: return
      LineNumberTable:
        line 8: 0
        line 9: 3
        line 10: 6
        line 11: 9
        line 12: 29
        line 14: 33
        line 18: 50
      StackMapTable: number_of_entries = 2
        frame_type = 255 /* full_frame */
          offset_delta = 46
          locals = [ class "[Ljava/lang/String;", class java/lang/String, class java/lang/String, class java/lang/String, class
java/lang/String, class java/lang/String ]
          stack = [ class java/io/PrintStream ]
        frame_type = 255 /* full_frame */
          offset_delta = 0
          locals = [ class "[Ljava/lang/String;", class java/lang/String, class java/lang/String, class java/lang/String, class
java/lang/String, class java/lang/String ]
          stack = [ class java/io/PrintStream, int ]
}
SourceFile: "Demo1_22.java"

常量池中的信息，都会被加载到运行时常量池中， 这时 a b ab 都是常量池中的符号，还没有变为 java 字符串对象,只有当执行到相应的jvm指令是才会将相应符号变为字符串对象

// StringTable [ "a", "b" ,"ab" ]  hashtable 结构，不能扩容
public class Demo1_22 {
    // 常量池中的信息，都会被加载到运行时常量池中， 这时 a b ab 都是常量池中的符号，还没有变为 java 字符串对象,只有当执行到相应的jvm指令是才会将相应符号变为字符串对象
    // ldc #2 会把 a 符号变为 "a" 字符串对象
    // ldc #3 会把 b 符号变为 "b" 字符串对象
    // ldc #4 会把 ab 符号变为 "ab" 字符串对象

    public static void main(String[] args) {
        String s1 = "a"; // 懒惰的
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1 + s2; // new StringBuilder().append("a").append("b").toString()  new String("ab")
        String s5 = "a" + "b";  // javac 在编译期间的优化，结果已经在编译期确定为ab

        System.out.println(s3 == s5);

    }
}

5.6 StringTable 特性

  • 常量池中的字符串仅是符号，第一次用到时才变为对象
  • 利用串池的机制，来避免重复创建字符串对象
  • 字符串变量拼接的原理是 StringBuilder （1.8）
  • 字符串常量拼接的原理是编译期优化
  • 可以使用 intern 方法，主动将串池中还没有的字符串对象放入串池
    • 1.8 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有则放入串池， 会把串池中的对象返回
    • 1.6 将这个字符串对象尝试放入串池，如果有则并不会放入，如果没有会把此对象复制一份，放入串池， 会把串池中的对象返回

5.7 StringTable面试题

public class StringTableQuestion {
    //[a,b,,ab,c,d,cd]                               StringTable
    //堆 s4(ab) StringBuilder.append  x2(cd)
    public static void main(String[] args) {
        String s1 = "a";
        String s2 = "b";
        String s3 = "a" + "b";
        String s4 = s1 + s2;
        String s5 = "ab";
        String s6 = s4.intern();
        System.out.println(s3 == s4); //false
        System.out.println(s3 == s5); //true
        System.out.println(s3 == s6);//true
        String x2 = new String("c") + new String("d");
        String x1 = "cd";
        x2.intern();
        System.out.println(x1 == x2);//false
    }
}

答案是false，true,true,false

首先程序开始运行，s1,s2依次入池，s3会在编译期进行优化，入池，s4两个变量进行拼接，程序中会调用StringBuilder在底层进行拼接，所以S4在堆中，因为池中已经存在了“ab”,所以s5不在入池，接着执行s4.intern(),因为池中已经存在了“ab",s4还是在堆中，s6返回的是串池中的对象，锁以接下来的三个结果就是false,true,true。

程序接着往下执行，在串池中依次放入c,b。x2对象在堆中。接着x1放入串池中，因为串池中已经存在cd,所以x2没有放入串池中，依然在堆中。所以接下来回输出false。

5.8 StringTable 位置

1.6是在永久代中，1.8时在堆中。见上图。

5.9 StringTable 垃圾回收

/**
 * 演示 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);
        }

    }
}


[GC (Allocation Failure) [PSYoungGen: 2046K->488K(2560K)] 2046K->742K(9728K), 0.0024306 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2536K->488K(2560K)] 2790K->782K(9728K), 0.0017411 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[GC (Allocation Failure) [PSYoungGen: 2536K->488K(2560K)] 2830K->798K(9728K), 0.0022217 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
100000
Heap
 PSYoungGen      total 2560K, used 1965K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 72% used [0x00000000ffd00000,0x00000000ffe71628,0x00000000fff00000)
  from space 512K, 95% used [0x00000000fff00000,0x00000000fff7a020,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 7168K, used 310K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 4% used [0x00000000ff600000,0x00000000ff64d8c0,0x00000000ffd00000)
 Metaspace       used 3522K, capacity 4504K, committed 4864K, reserved 1056768K
  class space    used 390K, capacity 392K, committed 512K, reserved 1048576K
SymbolTable statistics:
Number of buckets       :     20011 =    160088 bytes, avg   8.000
Number of entries       :     14205 =    340920 bytes, avg  24.000
Number of literals      :     14205 =    627672 bytes, avg  44.187
Total footprint         :           =   1128680 bytes
Average bucket size     :     0.710
Variance of bucket size :     0.714
Std. dev. of bucket size:     0.845
Maximum bucket size     :         6
StringTable statistics:
Number of buckets       :     60013 =    480104 bytes, avg   8.000
Number of entries       :     28122 =    674928 bytes, avg  24.000
Number of literals      :     28122 =   1655160 bytes, avg  58.856
Total footprint         :           =   2810192 bytes
Average bucket size     :     0.469
Variance of bucket size :     0.441
Std. dev. of bucket size:     0.664
Maximum bucket size     :         4

Process finished with exit code 0

从打印的信息中我们可以看到了进行垃圾回收

5.10 StringTable 性能调优

  • 调整 -XX:StringTableSize=桶个数
/**
 * 演示串池大小对性能的影响
 * -Xms 为jvm启动时分配的内存，比如-Xms200m，表示分配200M

 -Xmx 为jvm运行过程中分配的最大内存，比如-Xms500m，表示jvm进程最多只能够占用500M内存

 -Xss 为jvm启动的每个线程分配的内存大小，默认JDK1.4中是256K，JDK1.5+中是1M

 * -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 减少内存占用
 * -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<String> 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. 直接内存

6.1 定义

Direct Memory

  • 常见于 NIO 操作时，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受 JVM 内存回收管理
public class Demo1_9 {
    static final String FROM = "F:\\12.mp4";
    static final String TO = "F:\\a.mp4";
    static final int _1Mb = 1024 * 1024;

    public static void main(String[] args) {
        io(); 
        directBuffer();
    }

    private static void directBuffer() {
        long start = System.nanoTime();
        try (FileChannel from = new FileInputStream(FROM).getChannel();
             FileChannel to = new FileOutputStream(TO).getChannel();
        ) {
            ByteBuffer bb = ByteBuffer.allocateDirect(_1Mb);
            while (true) {
                int len = from.read(bb);
                if (len == -1) {
                    break;
                }
                bb.flip();
                to.write(bb);
                bb.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("directBuffer 用时：" + (end - start) / 1000_000.0);
    }

    private static void io() {
        long start = System.nanoTime();
        try (FileInputStream from = new FileInputStream(FROM);
             FileOutputStream to = new FileOutputStream(TO);
        ) {
            byte[] buf = new byte[_1Mb];
            while (true) {
                int len = from.read(buf);
                if (len == -1) {
                    break;
                }
                to.write(buf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        long end = System.nanoTime();
        System.out.println("io 用时：" + (end - start) / 1000_000.0);
    }
}

使用io读写时的原理：

在这里插入图片描述

使用NIO读写时原理：

在这里插入图片描述

6.2 分配和回收原理

  • 使用了 Unsafe 对象完成直接内存的分配回收，并且回收需要主动调用 freeMemory 方法
  • ByteBuffer 的实现类内部，使用了 Cleaner （虚引用）来监测 ByteBuffer 对象，一旦 ByteBuffer 对象被垃圾回收，那么就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来

结尾语：首先我写的jvm系列是在一个本人认为一个很好的教jvm的视频教程的笔记的基础上改的，加入了自己的一些修改和理解，由于是初学JVM,可能某些方面写的不对，请积极指教。如果觉得我改的烂，可以路过，不喜勿喷，写博客只是为了记录自己学习中的一些问题。附上个人认为不错的教程地址。
https://www.bilibili.com/video/BV1yE411Z7AP?from=search&seid=2688930742873346466

爱哭的毛毛虫好汉歌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JVM】尚硅谷宋红康JVM系列1：内存与垃圾回收篇
Java
06-05 2035
文章目录 b站视频地址： https://www.bilibili.com/video/BV1PJ411n7xZ/?p=2
一点一滴探究JVM之内存结构
02-25
我一直尝试着用不一样的文字来写博客！...今天的一点一滴探究JVM系列，打算复习一下jvm内存结构！至于学习这块知识的好处？一，从面试的角度来看，你了解jvm，并且java基础扎实，你才更有竞争力(因为我本人本科还没毕业
深入理解JVM-内存结构
matafeiyanll的博客
08-03 745
深入理解JVM-内存结构 [视频链接：
JVM虚拟机系列：内存结构&内存管理
C++ JAVA的专栏
10-10 195
JVM虚拟机系列：内存结构
JAVA内存模型与JVM内存结构
weixin_43681666的博客
03-03 1736
注意区分Java内存模型（Java Memory Model，简称JMM）与Jvm内存结构，前者与多线程相关，后者与JVM内部存储相关。本文会对两者进行简单介绍。
JVM 虚拟机系列：内存结构之栈区（虚拟机栈中的栈帧结构之动态链接）
C++ JAVA的专栏
02-18 376
JVM 虚拟机系列：内存结构之栈区（虚拟机栈中的栈帧结构之动态链接）
jvm系列（二）：JVM内存结构
qq_38836118的博客
05-10 1559
所有的Java开发人员可能会遇到这样的困惑？我该为堆内存设置多大空间呢？OutOfMemoryError的异常到底涉及到运行时数据的哪块区域？该怎么解决呢？其实如果你经常解决服务器性能问题，那么这些问题就会变的非常常见，了解JVM内存也是为了服务器出现性能问题的时候可以快速的了解那块的内存区域出现问题，以便于快速的解决生产故障。 先看一张图，这张图能很清晰的说明JVM内存结构布局。Java的内存结...
JVM 虚拟机系列：内存结构之栈区（虚拟机栈中的栈帧结构之方法返回地址）
C++ JAVA的专栏
02-18 535
JVM 虚拟机系列：内存结构之栈区（虚拟机栈中的栈帧结构之方法返回地址）
JVM详解——内存结构
eyes++的博客
02-08 3388
JVM是Java Virtual Machine(Java虚拟机)的缩写，JVM是一种用于计算设备的规范，具体实现有很多，以下内容如果不额外声明，默认是HotSpot JVM。JVM它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码(字节码)，就可以在多种平台上不加修改地运行。
jvm系列一：jvm结构
huangmr的专栏
06-12 1124
本博文主要介绍了JVM(Java Virtual Machine)的组成部分以及它们内部的工作机制和原理。需要注意的是，虽然平时我们用的大多是Sun（现已被Oracle收购）JDK提供的JVM，但是JVM本身是一个规范，所以可以有多种实现，除了Hotspot外，还有诸如Oracle的JRockit、IBM的J9也都是非常有名的JVM。 1. 结构 下图展示了JVM的主要结构：
JVM上篇：内存与垃圾回收
weixin_49561445的博客
10-24 2098
注：本文浓缩了宋红康老师JVM 入门到精通上篇（内存与垃圾回收）的精华 文章目录JVMJVM 的位置JAVA代码的执行流程JVM 整体结构JVM 的架构模型JVM的生命周期主流JVM 的发展历程类的加载子系统类的加载子系统的作用类的加载过程加载链接类的初始化类的加载器分类虚拟机自带的加载器获取ClassLoader 的实例双亲委派机制工作原理优势类的主动使用和被动使用主动使用运行时数据区程序计数器介绍作用虚拟机栈栈内部的存储结构栈帧的结构局部变量表操作数栈动态链接方法的调用虚方法与非虚方法方法返回地址本地方
详解JVM中的本机内存跟踪
08-25
在Java虚拟机（JVM）中，内存管理不仅限于Java堆内存，还包括一系列的非堆内存区域，这些区域在运行时对程序性能至关重要。本文将深入探讨JVM中的本机内存跟踪，揭示那些可能超出-Xms和-Xmx指定限制的内存消耗来源。...
gdxmachine：基于JVM的2D游戏引擎
02-03
它提供了一系列的游戏开发工具，包括图形渲染、音频处理、输入管理等，使得开发者可以专注于游戏逻辑，而非底层技术细节。 gdxmachine特别强调使用Kotlin进行开发。Kotlin是一种现代、类型安全的静态类型编程语言，...
小菜鸟系列-JVM体系结构
04-10
**小菜鸟系列-JVM体系结构** Java虚拟机（JVM）是Java平台的核心组成部分，它为Java程序提供了跨平台的运行环境。理解JVM的体系结构对于优化代码性能、排查故障以及深入理解Java编程至关重要。在本文中，我们将探讨...
【jvm】字符串常量池问题
王佑辉的博客
07-13 707
3.如果常量池中已经包含了一个等于此String对象的字符串（使用equals(Object)方法确定），则返回代表池中这个字符串的String对象的引用。9. 19 new #4 ： new一个String对象，对象的引用压入操作数栈。4. 7 new #4 ：new一个String对象，对象的引用压入操作数栈。3.简化字符串比较：由于字符串常量池中的字符串是唯一的，可以使用==操作符来比较字符串的引用，从而简化比较操作。
jvm 07 GC算法，内存池
qq_38757863的博客
07-10 327
01。
JVM的三种垃圾回收算法
最新发布
Jilit_jilit的博客
07-15 342
JVM的三种垃圾回收算法，及优缺点
JVM：运行时数据区
玉汝于成
07-13 693
程序计数器（Program Counter Register）也叫PC寄存器，每个线程会通过程序计数器记录当前要执行的字节码指令的地址。在加载阶段，虚拟机将字节码文件中的指令读取到内存之后，会将源文件中的偏移量转换成内存地址。每一条字节码指令都会拥有一个内存地址。在代码执行的过程中，程序计数器会记录下一行字节码指令地址。执行完当前指令之后，虚拟机的执行引擎根据程序计数器执行下一行指令。程序计数器可以控制程序指令的进行，实现分支、跳转、异常等逻辑。
垃圾收集篇
aaaPostcard的博客
07-14 824
文章目录垃圾收集算法垃圾的概念对象存活的判断引用计数器法可达性分析算法算法标记清除算法复制算法标记压缩算法垃圾收集的相关概念STW安全点安全区域垃圾收集器重要指标吞吐量停顿时间垃圾收集器的分类Serial 收集器：串行回收ParNew 收集器：并行回收Parallel Scavenge 收集器：吞吐量优先CMS收集器：低延迟G1 收集器：区域化分代 垃圾收集算法 垃圾的概念   在运行的程序中，当一个对象没有任何指针指向它时，它就会被视为垃圾。所以，判断一个对象是否被视为垃圾的关键标准就是是否由指针指向它。
深入解析：JVM执行子系统关键原理与结构详解
JVM执行子系统是Java虚拟机的核心组成部分，它负责将Java源代码编译后的.class文件转换为可执行的字节码，并确保其在内存中高效运行。本文将深入探讨JVM执行子系统的几个关键方面： 1. **类文件结构与字节码指令** ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值