JVM 内存结构和加载过程

最新推荐文章于 2023-02-15 10:47:41 发布
最新推荐文章于 2023-02-15 10:47:41 发布
阅读量205 收藏 1
点赞数
分类专栏： JVM 文章标签： jvm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42063050/article/details/114019410
版权

一、JVM内存结构

在这里插入图片描述
其中堆和方法区是线程共享的，虚拟机栈，程序计数器，本地方法栈是线程隔离的

堆：JVM 最大的内存空间，就大部分对象都是存在堆内存中的，堆内存又做了细分，分为了新生代和老年代还有一个 jdk8之前是永久代，jdk8 及其以后都是元空间，元空间并不是堆内存的一部分，而是本地内存。

在这里插入图片描述
From Survivor 和 to Survivor 是存活区，垃圾回收使用复制算法的时候会用到

虚拟机栈：是线程独享的，当创建线程的时候就会创建虚拟机栈，虚拟机栈由栈帧组成，每一次的方法调用都会创建栈帧，每次方法的调用返回都会对应着入栈和出栈操作

在这里插入图片描述
本地方法栈：和虚拟机栈类似，虚拟机栈管理 java 方法，本地方法栈管理的是 native 方法，本地方法都是由 C 语言完成的

程序计数器：用来记录各个线程执行的字节码的地址，像分支、循环、跳转、异常等都需要依赖程序计数器；为什么需要程序计数器呢？java 是多线程语言，当执行的线程数量超过 CPU 核心时，线程之间会根据时间片争抢 CPU资源，如果某个线程还没执行完，就被另一个线程抢去了 CPU资源，那下次这个线程再抢到 CPU资源的时候，运行到哪了呢？这就需要程序计数器来记录了。

方法区：线程共享的，主要包括静态变量，字符串常量池，运行时常量池，类信息，静态常量池

静态常量池：也叫class文件常量池，主要存放字面量（例如文本字符串、final修饰的常量），
符号引用（例如类和接口的全限定名、字段的名称和描述符、方法的名称和描述符）

运行时常量池：当类加载到内存中后，JVM就会将静态常量池中的内容存放到运行时的常量池中；运行时常量池里面存储的主要是编译期间生成的字面量、符号引用等等。

字符串常量池：也可以理解成运行时常量池分出来的一部分，类加载到内存的时候，字符串会存到字符串常量池里面

大于等于 jdk8 的方法区
在这里插入图片描述

为什么要用元空间代替永久代？主要有两方面的原因：
1、Oracle把HotSpot和JRockit 虚拟机都收购了，为了合并HotSpot和JRockit的代码，而JRockit没有永久代（PS：是不是JRockit团队打赢了胜仗呢 奸笑脸.jpg）
2、元空间存在于本地内存，意味着只要本地内存足够，它不会出现像永久代中“java.lang.OutOfMemoryError: PermGen space”这种错误。

二、类加载过程

在这里插入图片描述

1、编译：

java代码需要先编译成.class文件才能被 java 虚拟机运行，刚学 java 的时候一般都会运行一段 Hello World 程序来正式踏入 java 的世界，一般使用文本编译器写下如下代码：

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

然后使用 javac 命令编译这段代码

javac Test.java

会生成一个 Test.class 文件 ，如果用文本编辑器打开会看到一段“天书”，如下：

cafe babe 0000 0034 001d 0a00 0600 0f09
0010 0011 0800 120a 0013 0014 0700 1507

我只截取了其中 2 行

使用命令：

javap -v -p Test 

// 描述信息
Classfile /src/test/java/Test.class
 Last modified 2021-2-24; size 413 bytes
  MD5 checksum d0f5daff29065702d8fac7c86b57070b
  Compiled from "Test.java"
// 描述信息
public class Test
  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            // Test
   #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               Test.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               Test
  #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 Test();
    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 1: 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
         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 3: 0
        line 4: 8
}
SourceFile: "Test.java"

指令表查看：
指令表查看

2、加载

读取类的二进制流
转为方法区数据结构，并存放到方法区
在Java堆中产生java.lang.Class对象

3、链接

链接里又包含三个小步骤：

3.1、验证
作用：验证 class 文件是不是符合规范

  • 文件格式的验证
    ● 是否以 0xCAFEBABE 开头
    ● 版本号是否合理

  • 元数据验证
    ● 是否有父类
    ● 是否继承了final类( final类不能被继承,如果继承了就有问题了。)
    ● 非抽象类实现了所有抽象方法

  • 字节码验证
    ● 运行检查
    ● 栈数据类型和操作码操作参数吻合(比如栈空间只有2字节，但其实却需要大于2字节,此时就认为这个字节码是有问题的)
    ● 跳转指令指向合理的位置

  • 符号引用验证
    ● 常量池中描述类是否存在
    ● 访问的方法或字段是否存在且有足够的权限

可使用.Xverify:none关闭验证

3.2、准备

  • 作用:为类的静态变量分配内存,初始化为系统的初始值
    ● final static修饰的变量:直接赋值为用户定义的值,比如private final static int value = 1 ,直接赋值1
    ● private static int value = 123 ,该阶段的值依然是0

3.3、解析

作用:符号引用转换成直接引用

符号引用和直接引用

 #1 = Methodref          #6.#15         // java/lang/Object."<init>":()V
 #2 = Fieldref           #16.#17        // java/lang/System.out:Ljava/io/PrintStream;

如上 Methodref、Fieldref 为符号引用，要想真正引用到这些方法、变量、类等信息，就需要把这些符号转化成能够找到的对象指针，或者是对象的地址偏移量，转换之后的引用就是直接引用。
再直白点符号引用就是做了一个标记说我要去引用谁，而直接引用就是真正引用的对象

4、初始化

  • 执行方法，clinit方法由编译器自动收集类里面的所有静态变量的赋值动作及静态语句块合并而成,也叫类构造器方法
  • 初始化的顺序和源文件中的顺序一致
    static {
        i = 1;
    }

    static int i = 0;

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

输出为 0

  static int i = 0;

    static {
        i = 1;
    }

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

输出为 1

  • 子类的 clinit 被调用前,会先调用父类的 clinit
  • JVM 会保证 clinit 方法的线程安全性
  • 初始化时,如果实例化一个新对象,会调用方法对实例变量进行初始化,并执行对应的构造方法内的代码。
    static {
        System.out.println("静态代码块");
    }

    {
        System.out.println("构造块");
    }

    public Test() {
        System.out.println("构造方法");
    }

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

输出结果：

静态代码块
main
构造块
构造方法


public class Test {

    static {
        System.out.println("Test 静态代码块");
    }

    {
        System.out.println("Test 构造块");
    }

    public Test() {
        System.out.println("Test 构造方法");
    }

    public static void main(String[] args) {
        new Sub();
    }
}

class Super {
    static {
        System.out.println("Super 静态代码块");
    }

    {
        System.out.println("Super 构造块");
    }

    public Super() {
        System.out.println("Super 构造方法");
    }
}

class Sub extends Super {
    static {
        System.out.println("Sub 静态块");
    }

    public Sub() {
        System.out.println("Sub 构造方法");
    }

    {
        System.out.println("Sub 构造块");
    }
}

输出结果：

Test 静态代码块
Super 静态代码块
Sub 静态块
Super 构造块
Super 构造方法
Sub 构造块
Sub 构造方法

上面只是常规的类加载流程，实际上 JVM 并会不完全按照上面的加载顺序执行，比如说解析不一定在初始化之前

今天的文章就到这里，感兴趣的可以扫微信关注一下

在这里插入图片描述

javaer工具人
关注
专栏目录
JVM内存结构
阿杰同学的博客
12-24 1583
JVM的内存结构大概分为： 堆（Heap）：线程共享。所有的对象实例以及数组都要在堆上分配。回收器主要管理的对象。 方法区（Method Area）：线程共享。存储类信息、常量、静态变量、即时编译器编译后的代码。 方法栈（JVM Stack）：线程私有。存储局部变量表、操作栈、动态链接、方法出口，对象指针。 本地方法栈（Native Method Stack）：线程私有。为虚拟机使用到的Native 方法服务。如Java使用c或者c++编写的接口服务时，代码在此区运行。 程序计数器（Program Co.
JVM--详解对象分配内存过程
蛙广志
03-09 387
本文将详解描述一个对象从生到死的过程 在java世界里，“几乎”所有的对象实例都在这里分配内存，而这里的几乎由于即时编译技术的进步，尤其是逃逸分析技术的日益强大，使得对象可以在栈上分配 首先给出整体过程 前提：本文的回收过程仍以分代GC回收器为基础 栈上分配 不同于大家所熟知的对象分配在堆空间中，在GC中中会回收堆中不再使用的对象，但标记筛选以及回收整理空间都需要消耗大量资源，所以如果一个对象能分配在栈空间中，不在使用时可以直接从栈中弹出，不在经过 ...
深入理解JVM之一：JVM内存结构以及加载过程
我的java进阶之路
05-06 159
概述 首先先看一个简要图： 其中loadClass的类加载过程有如下几步： 加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载 加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口 验证：校验字节码文件的正确性 准备：给类的静态变量分配
JVM加载过程，以及内存模型相关
qq_34402635的博客
04-10 166
24、JVM 如何加载类的？ JVM 类加载机制分为五个部分：加载，验证，准备，解析，初始化。 加载是类加载过程中的一个阶段， 这个阶段会在内存中生成一个代表这个类 java.lang.Class对象， 作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。 验证这一阶段的主要目的是...
JVM学习02——内存加载过程（类加载器）
niTaoTaoa的博客
08-09 333
如果没有就继续往上问Bootstrap加载了吗，如果有就返回，没有，就让 Extension加载器加载，如果找到就加载，如果没有找到，就让App加载器去加载，如果找到就加载，自定义了类加载器，则先用自定义的类加载器，它内部维护一个缓存，记录这个class是否被加载进来了，如果没加载进来，就回去问App加载器是否加载了，加载就返回结果，父加载器不是 “类加载器的加载器”，也不是“类加载器的父类加载器” ，只是上一层次的更高级的加载器;否则就再往上问，问Extension加载器加载了吗，如果有就返回结果，...
【Java高级】JVM内存区域模型和加载过程
将来的你
07-12 1786
JVM内存区域模型    1.方法区 也称"永久代” 、“非堆”，  它用于存储虚拟机加载的类信息、常量、静态变量、是各个线程共享的内存区域。默认最小值为16MB，最大值为64MB，可以通过-XX:PermSize 和 -XX:MaxPermSize 参数限制方法区的大小。 运行时常量池：是方法区的一部分，Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常
JVM内存结构和Java内存模型别再傻傻分不清了
clonechen
05-23 5万+
JVM内存结构和Java内存模型都是面试的热点问题，名字看感觉都差不多，网上有些博客也都把这两个概念混着用，实际上他们之间差别还是挺大的。 通俗点说，JVM内存结构是与JVM的内部存储结构相关，而Java内存模型是与多线程编程相关，本文针对这两个总是被混用的概念展开讲解。 文章目录JVM内存结构JVM构成JVM内存结构程序计数器虚拟机栈本地方法栈堆方法区GC垃圾回收机制1. 垃圾判别方法引用计数算法可达性分析算法2. 垃圾回收算法标记清除法标记整理法复制算法3. 分代垃圾回收机制4. 垃圾回收器5. 四种引
JVM内存结构.pdf
03-03
2. **运行时数据区**：即通常所说的JVM内存结构，包括方法区、堆、栈、本地方法栈和程序计数器。 3. **执行引擎**：解释或编译Java字节码并执行。 #### 三、运行时数据区详解 ##### 1. 方法区(Method Area) - **...
笔记 — JVM内存结构
12-21
了解JVM内存结构有助于我们理解Java应用程序的内存分配和管理，从而进行更有效的内存优化，减少内存溢出和栈溢出等问题。例如，通过调整堆大小、优化对象生命周期、合理使用静态变量等策略，可以提高应用的性能和...
Jvm性能优化-JVM内存结构原理分析03
06-22
Jvm内存结构主要分为五部分：堆、虚拟机栈、本地方法栈、程序计数器和方法区。 堆是Jvm中最大的内存区域，所有线程共享的，主要用来存储对象。堆可以分为年轻代和老年代两块区域。年轻代又可以分为一个Eden区和两个...
JVM内存模型与类加载机制
weixin_30407099的博客
07-08 171
一. java虚拟机的内存模型如图: 补习一下jvm内存模型中的各个组成部分 堆: 我们new出来的对象全部放在堆中,他是jvm所能够动态分配的最大的一块空间 优点: 内存动态分配,生命周期不必事先告诉编译器,由JAVA的垃圾回收线程动态回收 栈: 存取的速度仅次于CPU的寄存器,但是存在栈里面的数据大小必须是提前定义的比如大家都知道int 4个字节 jvm在调用某些方法时...
JVM加载对象时内存加载顺序
weixin_34075551的博客
07-29 126
在开发中，有时会遇到这样的情况：我明明给一个变量赋值了，为什么在使用该变量时却是没有值的，这个和JVM的内存加载顺序有关，当你使用该变量时，这个变量还没初始化完成。 首先我们来看一段代码： public class ObjectLoadMemoryTest extends FuTest{ private int INT...
JVM内存模型（通俗易懂）
热门推荐
孤刺
10-30 22万+
1.什么是jvm? （1）jvm是一种用于计算设备的规范，它是一个虚构出来的机器，是通过在实际的计算机上仿真模拟各种功能实现的。 （2）jvm包含一套字节码指令集，一组寄存器，一个栈，一个垃圾回收堆和一个存储方法域。 （3）JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台上不加修改地运行。 JVM在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。 2.jdk、jre、jvm是什么关系？ （1）JRE(Java R
JVM内存管理的过程讲解
weixin_43407273的博客
10-26 124
  先看一段代码： public class StudentTest{ public static void main(String[] args){ int i = 10; Student student = new Student(); } }   接下来开始分析内存变化：   1、第一步进行类加载：将方法中需要的类文件加载到方法区中：   2、接下来，程序开始执行，首先，开始执行main()方法，将main()方法的栈桢放入栈内存中：   3、接下来执行第一条程序，创建一个int基本
JVM内存调优过程分享
weixin_37930980的博客
06-17 293
工程是采用的springboot框架构造的java工程，启动方式为java –jar 模式。 初始设置参数仅为JVM堆内存 –Xmx 512M –Xms256M，空跑情况下该java进程内存为500M， 压测时内存不溢出的情况下该java进程可高达1.5G,甚至更高，此时，导出jvm的dump文件分析发现，java堆内存占用比较少仅200M左右，于是有如下疑问, Q1:剩下的内存约1.2G左右的内存到底被谁占用了？ Q2:如何合理减少整个java进程所占用的内存？...
JVM内存模型-类加载过程
最新发布
mmzzy20150928的博客
02-15 94
类的加载过程
Java面向对象之JVM内存解析、对象创建的过程
qq15035899256的博客
01-16 959
Java面向对象的学习，了解一下JVM内存解析，了解堆区、栈区、方法区分别存放什么；对象创建的过程，代码块执行的先后顺序。
JVM内存分配和加载机制
qq_36461021的博客
01-29 212
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的加载机制。
JVM类的加载过程
weixin_43465227的博客
09-27 301
JVM类的加载过程 1.加载Loading 1.1通过一个类的全限定名获取定义此类的二进制字节流 1.2将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构 1.3在内存中生存一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口 2.链接Linking 2.1验证(Verify) : 目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，保证被加载类的正确性，不会危害虚拟机自身安全。 主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证
JVM内存结构深度解析
对JVM内存结构的深入理解可以帮助开发者更好地调试代码，解决诸如StackOverflowError和OutOfMemoryError等运行时错误。 首先，我们来讨论一下程序计数器（ProgramCounterRegister）。这是每个线程都私有的内存区域...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值