【黑马JVM(1)】内存结构

JVM内存结构

  • JVM/JRE/JDK
    • 示例
  • JVM内存管理
    • JVM整体架构
    • 程序计数器
  • 虚拟机栈
    • 栈内存溢出
    • 线程诊断 top/ps -H/jstack
      • 案例一:CPU占用过多
      • 案例二: 程序运行很长时间没结果
  • 本地方法栈
    • 堆内存溢出
    • 堆内存诊断
      • 案例一:jps/jmap/jconsole工具使用
      • 案例二:垃圾回收后,内存占用仍然很高
  • 方法区
    • 方法区内存溢出
  • 常量池
    • StringTable
      • 示例一:字面量创建字符串
      • 示例二:字符串变量拼接
      • 示例三:字符串常量拼接
      • 示例三:intern方法
    • StringTable特性
      • StringTable优化
  • 直接内存
    • IO/DirectBuffer拷贝文件
      • 直接内存溢出
  • JVM参数

JVM/JRE/JDK

  • JVM: Java Virtual Machine的缩写,JVM是一种用于计算设备的规范,它是一个虚构出来的计算
    机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。
    JVM 保正确执行 .class 文
    件,实现在 Linux、Windows、MacOS 等平台上运行。
  • JRE Java Runtime Environment的缩写,JVM 标准加上实现的一大堆基础类库就组成了Java的运行环境
    提供运行Java应用程序所必须的软件环境等。

JDK Java Development Kit的缩写,提供了一些非常好用的小工具,比如 javac、java、jar 等。
提供Java开发工具包

【黑马JVM(1)】内存结构_第1张图片
JVM好处:

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

示例

简单看下Java程序的执行过程:
【黑马JVM(1)】内存结构_第2张图片

【黑马JVM(1)】内存结构_第3张图片

运行下面代码:遵循的就是 Java 语言规范。其中,调用了System.out 等模块,也就是 JRE 里提供的类库。

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

使用 JDK 的工具 javac 进行编译后,会产生 HelloWorld 的字节码。javap查看下字节码内容:
【黑马JVM(1)】内存结构_第4张图片

控制端输入:javap -v HelloTest

javap 将class反编译
v显示基本信息

查看main方法内:

0 getstatic #2  // getstatic 获取静态字段的值
3 ldc #3  // ldc 常量池中的常量值入栈
5 invokevirtual #4  // invokevirtual 运行时方法绑定调用方法
8 return //void 函数返回

Java 虚拟机采用基于栈的架构,其指令由操作码和操作数组成。这些字节码指令,就叫作 opcode。其中,getstatic、ldc、invokevirtual、return 等,就是 opcode。
JVM 就是靠解析 opcode 和操作数来完成程序的执行的。当使用 Java 命令运行 .class 文件的时候,实际上就相当于启动了一个 JVM 进程。
然后 JVM 会翻译这些字节码,它有两种执行方式。

  • 常见的就是解释执行,将 opcode + 操作数翻译成机器代码;
  • 另外一种执行方式就是 JIT,即时编译,会在一定条件下将字节码编译成机器码之后再执行。

JVM内存管理

JVM整体架构

JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分。
【黑马JVM(1)】内存结构_第5张图片

程序计数器

Program Counter Register 程序计数器记住下一条jvm指令要执行的地址。(Java对硬件的抽象物理上通过寄存器实现(读取速度快))

当前指令所在的内存地址+当前指令所占用的字节数=下一条指令所在的内存地址

虚拟机指令的执行流程: 拿到一条指令,通过解释器翻译成机器码,才能交给CPU运行,程序计数器就是记住下一条jvm指令的执行地址。
【黑马JVM(1)】内存结构_第6张图片
【黑马JVM(1)】内存结构_第7张图片
观察这张图,不难发现每个指令前都有一个数字,这是指令的偏移地址,简称为行号,程序计数器的作用就是存储下一条指令的行号。
  以上图为例,当第一条指令执行时,JVM会将下一条指令的行号“3”放入程序计数器中。当第一条指令执行完时,解释器会根据程序计数器中的行号拿到下一条指令,继续运行。

为什么要多此一举先把下一条指令的行号放入程序计数器中,直接取指令然后执行不是更简单吗?
  JVM是支持多个线程同时运行的,这就涉及到CPU的调度问题了。线程甲正执行的好好的, 大哥CPU告诉甲说,你累了,我陪会儿乙,甲只好乖乖休息。一段时间后,大哥回来了,这时甲就可以根据程序计数器中的行号取到下一条指令接着执行。
  这里有一点要注意,因为程序计数器记录的是行号,是会重复的,所以多个线程不能同时用一个,不然就乱了。所以程序计数器是线程私有的。
  
特点:

  • 是线程私有的(每个线程执行的指令地址不一样)
  • 不会存在内存溢,程序计数器中的行号永远只会有一个,当前指令执行时,会拿下一条指令的行号替换当前的行号。因此就不存在内存溢出问题。

查看二进制字节码:

1.安装插件:
【黑马JVM(1)】内存结构_第8张图片
2.查看

【黑马JVM(1)】内存结构_第9张图片

虚拟机栈

Java Virtual Machine Stacks 虚拟机栈,线程运行时所需要的内存空间。
一个线程对应一个虚拟机栈,多个线程对应多个虚拟机栈。
一个虚拟机栈,由多个栈帧(Frame)组成。一个栈帧对应着一次方法调用,方法调用时所需要的内存为栈帧,存储参数,局部变量,返回地址等。
每个线程只能有一个活动栈帧,对应着当前正在执行的那个方法。

垃圾回收是否涉及栈内存?
不涉及,栈内存是一次次方法调用时所产生的栈帧内存,栈帧内存在每次方法调用结束后会弹出栈,自动回收掉。
垃圾回收只会回收掉对内存中的内存占用,栈内存不需要。

栈内存分配越大越好吗?

-Xss 设置栈帧大小

操作系统默认栈大小:
【黑马JVM(1)】内存结构_第10张图片
每个线程在创建的时候都会创建一个虚拟机栈,而物理内存是固定的,栈内存划分的越大, 可分配的线程数就越少。

方法内的局部遍历是否线程安全?
如果方法内部局部变量没有逃离方法的作用范围它就是安全的,是线程私有的 (栈帧独有),不会产生在多个线程下产生线程干扰。
​ 如果局部变量引用了对象,并逃离方法的作用范围,能被其他线程访问到,就不是线程安全的。

【黑马JVM(1)】内存结构_第11张图片

栈内存溢出

1.栈帧过多导致栈内存溢出(递归调用)

2.栈帧过大导致栈内存溢出

【黑马JVM(1)】内存结构_第12张图片

栈帧设置为256k,只循环3237次
【黑马JVM(1)】内存结构_第13张图片

线程诊断 top/ps -H/jstack

案例一:CPU占用过多

nohup java cc.java &

nohup 是 no hang up 的缩写,意思是不挂断运行,一直运行下去
& 是在后台运行的意思

top 命令检测进程对CPU的使用,定位哪个进程对cpu占用过高

【黑马JVM(1)】内存结构_第14张图片

ps H -eo pid,tid,%cpu

ps 查看线程情况
H 打印进程数
eo 输出要查看的内容 pid(进程ID) tid (线程id) %cpu
【黑马JVM(1)】内存结构_第15张图片

ps H -eo pid,tid,%cpu | grep 32655 定位哪个线程对CPU占位过高

【黑马JVM(1)】内存结构_第16张图片

jstack 32655(进程id) 会输出相关堆栈信息

jstack输出的线程信息是16进制的,我们将tid 32665 用计算器转为10进制可以看到是 7f99
线程的状态是runnable,显示第8行有问题,可以定位到Java源代码
在这里插入图片描述

案例二: 程序运行很长时间没结果

运行一段程序,想输出一个结果,但是一直不输出,可以查看相关堆栈信息

jstack pid

jstack最后一段输出中,发现Found one Java-Level deadlock,找到死锁,定位到Java源码的Thread-1的29行和Thread-0的21行。
【黑马JVM(1)】内存结构_第17张图片

本地方法栈

Native Method Stacks:java虚拟机调用本地方法时,所提供的内存空间。
本地方法定义:不是由java代码写的方法,由C或C++所写(因为c/c++方便和操作系统打交道,Java间接的通过调用本地方法来进行工作)。

本地方法例如:Object类,native修饰符等,Java的基础类库或执行引擎里都会调用本地方法。

Heap:通过 new 关键字创建对象都会使用堆内存。

特点

  • 是线程共享的,所以堆中的对象都需要考虑线程安全的问题
    虚拟机栈中的局部变量都是线程私有的,只要它的局部变量不逃逸出方法的作用范围,就是线程安全的,但是堆中的对象,要考虑线程安全,因为它们是线程共享的。当然也有例外,后面讲解。
  • 堆里面有一个垃圾回收机制
    堆中不再被引用的对象,就会当成垃圾进行回收,以释放空闲的内存,不至于内存被创建的对象给撑爆。

堆内存溢出

当一个对象不被使用时,就可以成为所谓垃圾被回收掉,也就是它占用的内存会被释放掉。怎么还可能出现堆内存耗尽呢?

可以被回收的一个对象的条件是没人在使用它,但是如果不断的产生对象,而产生的这些新对象,仍然被使用,就意味着这些对象不能作为垃圾,这样的对象达到一定的数量,就会导致堆内存被耗尽,即堆内存溢出。

代码示例:

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

初始的时候,a变量引用"hello",第一次变量,会把hello放入List集合中,接下来做一个字符串的拼接,变成了两个hello,组成了一个新的字符串,再循环的时候,会把两个hello的字符串对象。再追加到list集合,再做一次的拼接。以此类推,不断地把拼接的Hello对象加入list集合中,list的作用范围是从声明开始,一直都是有效范围,所以不能被垃圾回收掉,随着这个字符串就越来越多,它就会把堆空间占满。
【黑马JVM(1)】内存结构_第18张图片

Xmx 设置堆内存大小

控制堆空间的一个最大值,改小之后只循环17次。
【黑马JVM(1)】内存结构_第19张图片
在这里插入图片描述

堆内存诊断

案例一:jps/jmap/jconsole工具使用

代码示例:

public class Demo1_4 {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("1...");
        Thread.sleep(30000); //停留时间敲命令
        byte[] array = new byte[1024 * 1024 * 10]; // 10 Mb
        System.out.println("2...");
        Thread.sleep(20000);
        array = null; //变量数组不再引用
        System.gc();//进行垃圾回收
        System.out.println("3...");
        Thread.sleep(1000000L);
    }
}

jps 查看当前系统中有哪些java进程,并展示进程号

【黑马JVM(1)】内存结构_第20张图片

jmap 查看进程在堆内存占用情况,只能查询某个时刻

【黑马JVM(1)】内存结构_第21张图片
新创建的对象,都会使用eden Space区,used代表使用内存,capacity代表总容量
执行到1,查看堆内存使用情况:
【黑马JVM(1)】内存结构_第22张图片
执行到2,查看堆内存使用情况:增加了10M,就是创建的byte数组
【黑马JVM(1)】内存结构_第23张图片

执行到3,查看堆内存使用情况:包含一些不用的信息都回收掉了
【黑马JVM(1)】内存结构_第24张图片

jconsole工具

图形界面,多功能检测工具,可以连续监测,还可以查看内存占用,线程情况,类加载数量等信息。

启动代码,控制台输入jconsole
在这里插入图片描述

选择进程,直接连接
【黑马JVM(1)】内存结构_第25张图片
【黑马JVM(1)】内存结构_第26张图片

可以看到堆内存的使用情况:
【黑马JVM(1)】内存结构_第27张图片
【黑马JVM(1)】内存结构_第28张图片

还可以检测线程死锁
【黑马JVM(1)】内存结构_第29张图片

案例二:垃圾回收后,内存占用仍然很高

程序运行起来之后,并不知道程序代码怎么编写的,可以借助一些工具来查看一下。

jps 查看进程id

【黑马JVM(1)】内存结构_第30张图片

jmap - heap 13556 查看堆内存使用情况

【黑马JVM(1)】内存结构_第31张图片

jconsole 执行jc,但是堆内存还是200MB空间

是不是有一些由于我们的一些编程失误,导致了很一些对象始终被引用而无法释放他们的内存呢
【黑马JVM(1)】内存结构_第32张图片

使用 jvisualvm 工具

【黑马JVM(1)】内存结构_第33张图片

与jconsole类似,也可以监测一个内存的占用,执行垃圾回收,检测线程,查看堆各个组成成分。
【黑马JVM(1)】内存结构_第34张图片
堆dump工具,抓取堆的当前快照,可以进一步对里面的一些详细内容进行分析。这是jmap,jconsole 工具所不具备的。
【黑马JVM(1)】内存结构_第35张图片

查找保留前20个内存最大的对象,点进去查询细节:
【黑马JVM(1)】内存结构_第36张图片
可以看到student对象中big属性,是一个byte数组占用空间大约是一兆左右。每个student 对象占用一兆的内存,两百个对象占内存两百多兆。
排查出问题:student对象以及list导致内存占用比较高。而且这个对象是长时间使用的,导致垃圾回收没办法回收他们的内存。
【黑马JVM(1)】内存结构_第37张图片
查看Java源码:
student对象的属性的大小是1兆。循环了两百次,都加到了一个list 中,而这个list 由于一直在main方法里,而main方法一直没结束,所以都是在它的生存范围内,所以一直没能被回收,就导致内存占用居高不下。

/**
 * 演示查看对象个数 堆转储 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];
}

在实际的生产环境下分析的手段和排查的方式也是类似。通过堆转储功能(堆dump)把内存快照抓下来。再分析对内存占用最大的那些对象,就可以得出一些有用的结论,再去分析和排查你的原始代码就可以了。

方法区

jvm中对方法区的定义:Chapter 2. The Structure of the Java Virtual Machine

【黑马JVM(1)】内存结构_第38张图片
【黑马JVM(1)】内存结构_第39张图片

方法区是JVM所有线程共享的区域,它存储了与类结构相关的信息:运行时常量池,成员变量,方法数据,成员方法、构造方法的代码。它的大小就决定了系统可以保存多少种类。
  方法区在虚拟机启动时创建,它在逻辑上是堆的组成部分(具体实现上是否为堆的一部分视厂商而定,如永久代,元空间都是其实现)。JVM规范并不强制方法区的位置。

方法区的大小决定了系统可以保存多少个类,如果系统定义了太多的类会出现OOM错误。

在JDK 7以前,习惯上把方法区称为永久代(习惯上),而到了JDK8,终于完全废弃了永久代的概念,改用与JRockit、J9一样在本地内存中实现的元空间(Metaspace)来代替。这两个最大的区别就是:元空间不在虚拟机设置的内存中,而是使用本地内存。

【黑马JVM(1)】内存结构_第40张图片
【黑马JVM(1)】内存结构_第41张图片

方法区用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等。
【黑马JVM(1)】内存结构_第42张图片

方法区内存溢出

代码示例:

/**
 * 演示元空间内存溢出 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);
        }
    }
}

运行之后并没有出现溢出,因为Java8之后使用元空间,使用的是系统内存,所以设置元空间初始大小为1.8
【黑马JVM(1)】内存结构_第43张图片

-XX:MaxMetaspaceSize=8m 设置原空间初始大小 1.8

【黑马JVM(1)】内存结构_第44张图片
1.8环境,Metaspace代表元空间导致的OOM

-XX:MaxMetaspaceSize=8m 设置元空间初始大小

【黑马JVM(1)】内存结构_第45张图片
1.6环境,PermGen代表是永久代导致的OOM。

XX:MaxPermSize=8m 设置永久代初始大小

【黑马JVM(1)】内存结构_第46张图片

常量池

JVM指令参考:https://blog.csdn.net/A598853607/article/details/125026953

通过一段代码认识常量池:

示例代码:

public class HelloWorld {
    public HelloWorld() {
    }

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

hello world要运行,需要先编译成二进制字节码。
字节码由三部分组成:类的基本信息,类的常量池,类中的一些方法定义(包含虚拟机指令)。

javap -v helloWord 查看二进制反编译后内容

PS D:\java\idea\IdeaProject2\jvm\out\production\jvm\cn\itcast\jvm\t5> javap -v HelloWorld
警告: 二进制文件HelloWorld包含cn.itcast.jvm.t5.HelloWorld
Classfile /D:/java/idea/IdeaProject2/jvm/out/production/jvm/cn/itcast/jvm/t5/HelloWorld.class
  Last modified 2023-2-15; size 567 bytes
  MD5 checksum 8efebdac91aa496515fa1c161184e354
  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.#20         // java/lang/Object."":()V
   #2 = Fieldref           #21.#22        // java/lang/System.out:Ljava/io/PrintStream;
   #3 = String             #23            // hello world
   #4 = Methodref          #24.#25        // java/io/PrintStream.println:(Ljava/lang/String;)V
   #5 = Class              #26            // cn/itcast/jvm/t5/HelloWorld
   #6 = Class              #27            // java/lang/Object
   #7 = Utf8               
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               Lcn/itcast/jvm/t5/HelloWorld;
  #14 = Utf8               main
  #15 = Utf8               ([Ljava/lang/String;)V
  #16 = Utf8               args
  #17 = Utf8               [Ljava/lang/String;
  #18 = Utf8               SourceFile
  #19 = Utf8               HelloWorld.java
  #20 = NameAndType        #7:#8          // "":()V
  #21 = Class              #28            // java/lang/System
  #22 = NameAndType        #29:#30        // out:Ljava/io/PrintStream;
  #23 = Utf8               hello world
  #24 = Class              #31            // java/io/PrintStream
  #25 = NameAndType        #32:#33        // println:(Ljava/lang/String;)V
  #26 = Utf8               cn/itcast/jvm/t5/HelloWorld
  #27 = Utf8               java/lang/Object
  #28 = Utf8               java/lang/System
  #29 = Utf8               out
  #30 = Utf8               Ljava/io/PrintStream;
  #31 = Utf8               java/io/PrintStream
  #32 = Utf8               println
  #33 = Utf8               (Ljava/lang/String;)V
{
  public cn.itcast.jvm.t5.HelloWorld();
    descriptor: ()V
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."":()V
         4: return
      LineNumberTable:
        line 4: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcn/itcast/jvm/t5/HelloWorld;

  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
         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
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
}
SourceFile: "HelloWorld.java"

类的基本信息:
【黑马JVM(1)】内存结构_第47张图片
常量池:
【黑马JVM(1)】内存结构_第48张图片
方法定义:
【黑马JVM(1)】内存结构_第49张图片
查看虚拟机指令:虚拟机指令后的注释是java程序帮忙加上的。解释器在翻译虚拟机指令的时候,只看到没加注释的这几行指令。
【黑马JVM(1)】内存结构_第50张图片
【黑马JVM(1)】内存结构_第51张图片
常量池就是一张常量表,jvm虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量(字符串和基本数据类型)等信息。
运行时常量池就是存在 *.class 文件中的,当该类被加载到虚拟机以后,它的常量池中的信息会被加载到运行时常量池中(在内存中的位置)。并把符号地址变为内存中的真实地址。

StringTable

在运行时常量池中,有一块逻辑区域是StringTable(串池),用于存放字面量,串池实际上是一个hash表,不能扩容。当jvm指令在执行时,当执行到字面量信息时,会去串池中查找是否有该字面量,如果没有该字面量将其放入到串池中。

示例一:字面量创建字符串

// StringTable [ "a", "b" ,"ab" ]  hashtable 结构,不能扩容
public class Demo1_22 {

    public static void main(String[] args) {
        String s1 = "a"; // 懒惰的
        String s2 = "b";
        String s3 = "ab";
    }
}

【黑马JVM(1)】内存结构_第52张图片

常量池中的信息,都会被加载到运行时常量池中, 这时 a b ab 都是常量池中的符号,还没有变为 java 字符串对象
当运行到此方法,执行到对应的代码时(jvm执行 ldc #2) 才会把 a 符号变为 “a” 字符串对象,并将对象放入串池(StringTable[]) 中,StringTable是一个哈希表,长度固定,“a”就是哈希表的key。一开始的时候,会根据“a”到串池中找其对象,一开始是没有的,所以就会创建一个并放入串池中。串池为 [“a”]。执行到指令ldc #3时,会和上面一样,生成一个“b”对象并放入串池中,串池变为[“a”, “b”]。同样地,后面会生成“ab”对象并放入串池中。串池变为[“a”, “b”, “ab”]。

小结一下:字面量创建字符串对象是懒惰的,即只有执行到相应代码才会创建相应对象(和一般的类不同)并放入串池中。如果串池中已经有了,就直接使用串池中的对象(让引用变量指向已有的对象)。串池中的对象只会存在一份,也就是只会有一个“a”对象。

普通的java对象在类加载的时候就会生成并放入堆中,而这种方式生成的String不同,只有当执行到新建String的代码时才会生成字符串对象。

astore_0 将引用类型或returnAddress类型值存入局部变量0

示例二:字符串变量拼接

// StringTable [ "a", "b" ,"ab" ]  hashtable 结构,不能扩容
public class Demo1_22 {

    public static void main(String[] args) {
        String s1 = "a"; // 懒惰的
        String s2 = "b";
        String s3 = "ab";
        String s4 = s1+s2;
		System.out.println(s3 == s4);  // false
    }
}

通过虚拟机指令明白:
行号为9的指令是个new,就说明s4的创建方式和s1、s2、s3不同,它是在堆里新建了一个对象,前面根据字面量创建的则是在串池中生成了字符串对象。通过后面的注释明白new了一个StringBuilder对象。接着看17,21,可以发现“s1 + s2”的方式是通过StringBuilder对象调用append方法实现的。最后看24,调用了toString方法生成了新的字符串对象。

所以:s1+s2的执行流程:new StringBuilder().append(“a”).append(“b”).toString()
【黑马JVM(1)】内存结构_第53张图片
StringBuilder.toString(),创建一个新的String对象,存入ab
【黑马JVM(1)】内存结构_第54张图片
说明:当两个字符串变量拼接时,jvm会创建一个StringBuilder对象,利用其append方法实现变量的拼接。最后再通过其toString方法生成一个新的String对象。

最后输出结果,发现s3不等于s4,这说明s3指向串池中的“ab”对象,s4指向堆中的“ab”对象。这是两个不同的对象。

示例三:字符串常量拼接

public class Demo1_22 {

    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";
        System.out.println(s3 == s5);//true

    }
}

【黑马JVM(1)】内存结构_第55张图片
行号为6时,串池中没有ab对象,就创建ab对象放入串池,执行到29行时要去常量池中找4号位置的ab符号,发现串池中已存在,就不会创建新的对象,直接引用即可。
为什么会以这种方式创建s5,其实是编译期的优化。y因为编译器发现这是两个常量a,b相加,结果在编译期间就可以确定为ab,不会再变。s4 = s1+s2,因为s1和s2是变量,在运行时被引用的值可能被修改,结果不能确定,所以要在运行时使用StringBuilder动态拼接。

示例三:intern方法

 public static void main(String[] args) {

        String x = "ab";
        String s = new String("a") + new String("b");

        // 堆  new String("a")   new String("b") new String("ab")
        String s2 = s.intern(); // 将这个字符串对象尝试放入串池,如果有则并不会放入,如果没有则放入串池, 会把串池中的对象返回

        System.out.println( s2 == x);//true
        System.out.println( s == x );//false
    }

【黑马JVM(1)】内存结构_第56张图片
通过虚拟机指令明白:
第一行代码看行号为0的指令,往串池中添加ab字符,
第二行代码从行号为3的指令new StringBuilder对象,调用他的空参构造器,行号10new String对象,行号14将a字符添加到串池中,实例化String对象,值为a,调用StringBilder的append方法,再new一个String对象,实例化值为b,StringBuilder拼接ab,调用toString方法。

intern方法的作用就是在尝试把堆中对象放入串池中。如果串池中已有,会返回串池中的对象。并且s调用intern方法后依旧指向堆中的对象。如果串池中没有,会在串池中创建一个“ab”对象并返回,并且会让s指向串池中的“ab”对象。
  
在jdk1.6,当一个String调用intern方法时,如果串池中没有,会将堆中的字符串对象复制一份放到串池中,最后返回串池中刚加入的对象。

StringTable特性

常量池中的字符串仅是符号,第一次用到时才变为对象
利用串池的机制,可以避免重复创建字符串对象
字符串变量拼接的原理是StringBuilder(jdk1.8)
字符串常量拼接的原理是编译器优化
可以使用intern方法,主动将串池中还没有的字符串对象放入串池

StringTable优化

  • -XX:StringTableSize=1009 调整StringTable桶个数,最小为1009,如果系统内字符串较多,可以适当增大该值
  • 如果有大量字符串且有重复。使用intern方法,将字符串入池减少字符串个数,节约堆内存的使用
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());
                    //address.add(line);
                }
                System.out.println("cost:" +(System.nanoTime()-start)/1000000);
            }
        }
        System.in.read();
    }
}

未入池之前内存对比:
【黑马JVM(1)】内存结构_第57张图片
【黑马JVM(1)】内存结构_第58张图片
入池之后内存对比:

【黑马JVM(1)】内存结构_第59张图片
【黑马JVM(1)】内存结构_第60张图片

直接内存

直接内存:Direct Memory,不属于Java虚拟机的内存管理,属于操作系统的内存。

  • 常见于 NIO 操作时,用于数据读取时缓冲区内存,
  • 分配回收成本较高,但读写性能高(Java使用系统内存,分配成本高些)
  • 不受 JVM 内存回收管理()

IO/DirectBuffer拷贝文件

/**
 * 演示 ByteBuffer 作用
 */
public class Demo1_9 {
    static final String FROM = "E:\\youtube\\Getting Started with Spring Boot-sbPSjI4tt10.mp4";
    static final String TO = "E:\\a.mp4";
    static final int _1Mb = 1024 * 1024;

    public static void main(String[] args) {
        io(); // io使用传统阻塞IO文件拷贝 用时:1535.586957 1766.963399 1359.240226
        directBuffer(); // directBuffer 使用缓冲区 用时:479.295165 702.291454 562.56592
    }

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

Java并不具备磁盘读写的能力,要调用操作系统的提供的方法。涉及到CPU要从用户态,切换到内核态。
【黑马JVM(1)】内存结构_第61张图片
切换到内存态后,就可以由CPU的函数读取磁盘文件的内容,读取数据后内核态会在操作系统内存中画出一块缓冲区,称为系统缓存区,磁盘内容会先读入到系统缓冲区中,系统缓冲区Java代码是不能运行的,Java会在堆内存中分配一块Java的缓冲区,对应Java中new byte[_1Mb],Java代码要能读取到流中的数据,必须要从系统缓存区中的数据间接的读入到Java缓冲区,再到用户态,Java调用输出流的写入操作,重复读写操作,将文件赋值到目标位置。
在这里插入图片描述
因为Java堆内存中有块缓冲区,系统内存中由块系统缓存区,数据必然要存两份,造成不必要的数据复制,效率不是很高。

使用ByteBuffer之后,allocateDirect方法会分配一块直接内存,会在操作系统中画出一块缓冲区,Java代码和系统都可以直接访问,磁盘文件读取会读取到直接内存,Java代码也可以直接访问直接内存,减少了一次复制操作。
【黑马JVM(1)】内存结构_第62张图片

直接内存溢出

public class Demo1_10 {
    static int _100Mb = 1024 * 1024 * 100;

    public static void main(String[] args) {
        List<ByteBuffer> list = new ArrayList<>();
        int i = 0;
        try {
            while (true) {
                ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_100Mb);
                list.add(byteBuffer);
                i++;
            }
        } finally {
            System.out.println(i);
        }
        // 方法区是jvm规范, jdk6 中对方法区的实现称为永久代
        //                  jdk8 对方法区的实现称为元空间
    }
}

【黑马JVM(1)】内存结构_第63张图片

显式的垃圾回收gc对内存占用的影响

public class Demo1_26 {
    static int _1Gb = 1024 * 1024 * 1024;

    /*
     * -XX:+DisableExplicitGC 禁用掉显式的垃圾回收之后,直接内存不能通过显示代码回收掉的话,只能等到真正的垃圾回收发生时才会被清理,对应的直接内存才会被清理。
     */
    public static void main(String[] args) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1Gb);
        System.out.println("分配完毕...");
        System.in.read();
        System.out.println("开始释放...");
        byteBuffer = null;
        System.gc(); // 显式的垃圾回收,不仅要回收新生代,还会回收老年代,导致程序暂定的时间较长 Full GC
        System.in.read();
    }
}

【黑马JVM(1)】内存结构_第64张图片
分配完毕。。。
【黑马JVM(1)】内存结构_第65张图片
gc垃圾回收后。。。
【黑马JVM(1)】内存结构_第66张图片

直接内存分配的底层原理:Unsafe

ByteBuffer底层分配和释放直接内存的类型为Unsafe类,jdk内部使用Unsafe类,不建议程序员使用。

public class Demo1_27 {
    static int _1Gb = 1024 * 1024 * 1024;

    public static void main(String[] args) throws IOException {
        Unsafe unsafe = getUnsafe();
        // 分配内存,返回base代表刚分配的内存地址
        long base = unsafe.allocateMemory(_1Gb);
        unsafe.setMemory(base, _1Gb, (byte) 0);
        System.in.read();

        // 释放内存,通过内存地址释放
        unsafe.freeMemory(base);
        System.in.read();
    }
    

	//通过反射获取Unsafe对象
    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            Unsafe unsafe = (Unsafe) f.get(null);
            return unsafe;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

分配和回收原理
使用了 Unsafe 对象完成直接内存的分配回收,并且回收需要主动调用 freeMemory 方法
ByteBuffer 的实现类内部,使用了 Cleaner (虚引用类型)来监测 ByteBuffer 对象,一旦ByteBuffer 对象被垃圾回收,就会由 ReferenceHandler 线程通过 Cleaner 的 clean 方法调用 freeMemory 来释放直接内存。

垃圾回收对Java中无用的对象是自动释放的,不需手动调用方法,直接内存必须主动调用freeMemory()方法,才能完成对直接内存的释放。

JVM参数

-XX:+PrintStringTableStatistics 打印字符串表的统计信息,可以精准看到串池中实例个数和占用大小信息
-XX:+PrintGCDetails -verbose:gc 打印垃圾回收信息,次数已经花费时间
 -XX:StringTableSize=1009 调整StringTable桶个数,最小为1009,如果系统内字符串较多,可以适当增大该值
  -XX:+DisableExplicitGC 禁用掉显式的垃圾回收

 在jdk8下设置-XX:MaxMetaspaceSize=8m 设置元空间初始大小
 在jdk6下设置 -XX:MaxPermSize=10m 设置永久代初始大小

-Xmn10M 设置年轻代大小。整个堆大小=年轻代大小 + 年老代大小 + 常量池。
 -Xsx500m 
-Xms500m 初始堆内存大小,设定程序启动时占用内存大小
-Xmx500m  最大堆内存,设定程序运行期间最大可占用的内存大小
-Xss256k  设置单个线程栈大小,一般默认512~1024kb,设置栈帧大小

 -XX:+UseSerialGC

JVM参数参考:https://blog.csdn.net/dsydly/article/details/106303058

【黑马JVM(1)】内存结构_第67张图片

你可能感兴趣的:(JVM,jvm)