Java虚拟机详解----JVM内存结构

梦里梦外; 2022-05-27 14:15 186阅读 0赞

http://www.cnblogs.com/smyhvae/p/4748392.htm

主要内容如下：

*  JVM启动流程
 *  JVM基本结构
 *  内存模型
 *  编译和解释运行的概念

一、JVM启动流程：

[![587f1e97-d4ed-4d7f-89c6-dabe944fed12][]][587f1e97-d4ed-4d7f-89c6-dabe944fed12 1]

JVM启动时，是由java命令/javaw命令来启动的。

二、JVM基本结构：

JVM基本结构图：

[![16865f32-a87b-4fee-9aed-a793016cf2a7][]][16865f32-a87b-4fee-9aed-a793016cf2a7 1]

《深入理解Java虚拟机（第二版）》中的描述是下面这个样子的：

[![96698196-0f6b-4ef6-9a20-85dd35d75f27][]][96698196-0f6b-4ef6-9a20-85dd35d75f27 1]

Java中的内存分配：

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对数据进行了不同空间的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

具体划分为如下5个内存空间：（非常重要）

*  栈：存放局部变量
 *  堆：存放所有new出来的东西
 *  方法区：被虚拟机加载的类信息、常量、静态常量等。
 *  程序计数器(和系统相关)
 *  本地方法栈

1、程序计数器:

> 每个线程拥有一个PC寄存器
> 
> 在线程创建时创建
> 
> 指向下一条指令的地址
> 
> 执行本地方法时，PC的值为undefined

2、方法区:

> 保存装载的类信息
> 
> 　　类型的常量池
> 
> 　　字段，方法信息
> 
> 　　方法字节码
> 
> 通常和永久区(Perm)关联在一起

3、堆内存:

> 和程序开发密切相关
> 
> 应用系统对象都保存在Java堆中
> 
> 所有线程共享Java堆
> 
> 对分代GC来说，堆也是分代的
> 
> GC管理的主要区域

现在的GC基本都采用分代收集算法，如果是分代的，那么堆也是分代的。如果堆是分代的，那堆空间应该是下面这个样子：

[![8d74ba35-9865-4434-8be5-73cec9e93295][]][8d74ba35-9865-4434-8be5-73cec9e93295 1]

上图是堆的基本结构，在之后的文章中再进行详解。

4、栈内存：

*  线程私有，生命周期和线程相同
 *  栈由一系列帧组成（因此Java栈也叫做帧栈）
 *  帧保存一个方法的局部变量、操作数栈、常量池指针
 *  每一次方法调用创建一个帧，并压栈

解释：

Java虚拟机栈描述的是Java方法执行的内存模型：每个方法被调用的时候都会创建一个栈帧，用于存储局部变量表、操作栈、动态链接、方法出口等信息。每一个方法被调用直至执行完成的过程就对应着一个栈帧在虚拟机中从入栈到出栈的过程。

在Java虚拟机规范中，对这个区域规定了两种异常情况：

（1）如果线程请求的栈深度太深，超出了虚拟机所允许的深度，就会出现StackOverFlowError（比如无限递归。因为每一层栈帧都占用一定空间，而 Xss 规定了栈的最大空间，超出这个值就会报错）

（2）虚拟机栈可以动态扩展，如果扩展到无法申请足够的内存空间，会出现OOM

4.1 Java栈之局部变量表：包含参数和局部变量

局部变量表存放了基本数据类型、对象引用和returnAddress类型（指向一条字节码指令的地址）。其中64位长度的long和double类型的数据会占用2个局部变量空间（slot），其余数据类型只占用1个。局部变量表所需的内存空间在编译期间完成分配。

例如，我写出下面这段代码：

![复制代码][copycode.gif]

1 package test03;
     2 
     3 /**
     4  * Created by smyhvae on 2015/8/15.
     5  */
     6 public class StackDemo {
     7     
     8     //静态方法
     9     public static int runStatic(int i, long l, float f, Object o, byte b) {
    10         return 0;
    11     }
    12 
    13     //实例方法
    14     public int runInstance(char c, short s, boolean b) {
    15         return 0;
    16     }
    17 
    18 }

![复制代码][copycode.gif]

上方代码中，静态方法有6个形参，实例方法有3个形参。其对应的局部变量表如下：

[![1272c229-ef70-4898-9ede-66828e6b84f7][]][1272c229-ef70-4898-9ede-66828e6b84f7 1]

上方表格中，静态方法和实例方法对应的局部变量表基本类似。但有以下区别：实例方法的表中，第一个位置存放的是当前对象的引用。

4、2 Java栈之函数调用组成栈帧：

方法每次被调用的时候都会创建一个栈帧，例如下面这个方法：

public static int runStatic(int i,long l,float  f,Object o ,byte b){
           return runStatic(i,l,f,o,b);
    }

当它每次被调用的时候，都会创建一个帧，方法调用结束后，帧出栈。如下图所示：

[![1244af96-c081-4059-98de-7881ec4c792e][]][1244af96-c081-4059-98de-7881ec4c792e 1]

4.3 Java栈之操作数栈

Java没有寄存器，所有参数传递都是使用操作数栈

例如下面这段代码：

public static int add(int a,int b){
            int c=0;
            c=a+b;
            return c;
        }

压栈的步骤如下：

0: iconst\_0 // 0压栈

1: istore\_2 // 弹出int，存放于局部变量2

2: iload\_0 // 把局部变量0压栈

3: iload\_1 // 局部变量1压栈

4: iadd //弹出2个变量，求和，结果压栈

5: istore\_2 //弹出结果，放于局部变量2

6: iload\_2 //局部变量2压栈

7: ireturn //返回

如果计算100+98的值，那么操作数栈的变化如下图所示：

[![35721707-fff7-4516-86a7-dda30320dc06][]][35721707-fff7-4516-86a7-dda30320dc06 1]

4.4 Java栈之栈上分配：

> 小对象（一般几十个bytes），在没有逃逸的情况下，可以直接分配在栈上
> 
> 直接分配在栈上，可以自动回收，减轻GC压力
> 
> 大对象或者逃逸对象无法栈上分配

栈、堆、方法区交互：

[![7efdd9ad-03a3-41e8-9635-36d5506a23f9][]][7efdd9ad-03a3-41e8-9635-36d5506a23f9 1][![f29029fe-8cef-47ea-b091-e3f19d6a9801][]][f29029fe-8cef-47ea-b091-e3f19d6a9801 1]

三、内存模型：

每一个线程有一个工作内存。工作内存和主存独立。工作内存存放主存中变量的值的拷贝。

[![7883501b-7e5c-4064-af0d-438a118acbf6][]][7883501b-7e5c-4064-af0d-438a118acbf6 1]

当数据从主内存复制到工作存储时，必须出现两个动作：第一，由主内存执行的读（read）操作；第二，由工作内存执行的相应的load操作；当数据从工作内存拷贝到主内存时，也出现两个操作：第一个，由工作内存执行的存储（store）操作；第二，由主内存执行的相应的写（write）操作。

每一个操作都是原子的，即执行期间不会被中断

对于普通变量，一个线程中更新的值，不能马上反应在其他变量中。如果需要在其他线程中立即可见，需要使用volatile关键字作为标识。

[![d481032e-ed23-46c2-9c5c-5f34e3193ef9][]][d481032e-ed23-46c2-9c5c-5f34e3193ef9 1]

1、可见性：

一个线程修改了变量，其他线程可以立即知道

保证可见性的方法：

> volatile
> 
> synchronized （unlock之前，写变量值回主存）
> 
> final(一旦初始化完成，其他线程就可见)

2、有序性：

在本线程内，操作都是有序的

在线程外观察，操作都是无序的。（指令重排 或 主内存同步延时）

3、指令重排：

[![142d481b-f4a3-4c23-b56d-cf3ec5b63a2e][]][142d481b-f4a3-4c23-b56d-cf3ec5b63a2e 1]

指令重排：破坏了线程间的有序性：

[![154748eb-cc14-48ee-b66f-cdcc26068cd1][]][154748eb-cc14-48ee-b66f-cdcc26068cd1 1]

指令重排：保证有序性的方法：

[![e0bcca41-a6e1-4a5c-b723-e0d721875acc][]][e0bcca41-a6e1-4a5c-b723-e0d721875acc 1]

指令重排的基本原则：

> 程序顺序原则：一个线程内保证语义的串行性
> 
> volatile规则：volatile变量的写，先发生于读
> 
> 锁规则：解锁(unlock)必然发生在随后的加锁(lock)前
> 
> 传递性：A先于B，B先于C 那么A必然先于C
> 
> 线程的start方法先于它的每一个动作
> 
> 线程的所有操作先于线程的终结（Thread.join()）
> 
> 线程的中断（interrupt()）先于被中断线程的代码
> 
> 对象的构造函数执行结束先于finalize()方法

四、解释运行和编译运行的概念：

解释运行：

> 解释执行以解释方式运行字节码
> 
> 解释执行的意思是：读一句执行一句

编译运行（JIT）：

> 将字节码编译成机器码
> 
> 直接执行机器码
> 
> 运行时编译
> 
> 编译后性能有数量级的提升

编译运行的性能优于解释运行。

[587f1e97-d4ed-4d7f-89c6-dabe944fed12]: /images/20220527/22cf6a544aba4c0085274a39ab7c6e50.png
[587f1e97-d4ed-4d7f-89c6-dabe944fed12 1]: http://images0.cnblogs.com/blog/641601/201508/211701552859560.png
[16865f32-a87b-4fee-9aed-a793016cf2a7]: /images/20220527/8d91804263d14f0d9a4a0263cf949d3a.png
[16865f32-a87b-4fee-9aed-a793016cf2a7 1]: http://images0.cnblogs.com/blog/641601/201508/211701565193505.jpg
[96698196-0f6b-4ef6-9a20-85dd35d75f27]: /images/20220527/8eed70eec1de45e1a47a5d703eb73f2b.png
[96698196-0f6b-4ef6-9a20-85dd35d75f27 1]: http://images0.cnblogs.com/blog/641601/201508/211701576919962.jpg
[8d74ba35-9865-4434-8be5-73cec9e93295]: /images/20220527/cb58f9ae1c9a4563b837a749133e9d8a.png
[8d74ba35-9865-4434-8be5-73cec9e93295 1]: http://images0.cnblogs.com/blog/641601/201508/211701587536920.png
[copycode.gif]: /images/20220527/6496a4ccd206456bacf3e28f23cfdd78.png
[1272c229-ef70-4898-9ede-66828e6b84f7]: /images/20220527/697fc4d1029b44c9b54f102d39579090.png
[1272c229-ef70-4898-9ede-66828e6b84f7 1]: http://images0.cnblogs.com/blog/641601/201508/211701594726007.png
[1244af96-c081-4059-98de-7881ec4c792e]: /images/20220527/f3ff94f572bd47d48b910cc93cd68eb2.png
[1244af96-c081-4059-98de-7881ec4c792e 1]: http://images0.cnblogs.com/blog/641601/201508/211702005196194.png
[35721707-fff7-4516-86a7-dda30320dc06]: /images/20220527/b79cce7d91a14e188f3d41936057b4d2.png
[35721707-fff7-4516-86a7-dda30320dc06 1]: http://images0.cnblogs.com/blog/641601/201508/211702016287165.jpg
[7efdd9ad-03a3-41e8-9635-36d5506a23f9]: http://images0.cnblogs.com/blog/641601/201508/211702038944525.jpg
[7efdd9ad-03a3-41e8-9635-36d5506a23f9 1]: http://images0.cnblogs.com/blog/641601/201508/211702028166095.jpg
[f29029fe-8cef-47ea-b091-e3f19d6a9801]: /images/20220527/0f8946f5e23846608826d37c4840295c.png
[f29029fe-8cef-47ea-b091-e3f19d6a9801 1]: http://images0.cnblogs.com/blog/641601/201508/211702046758695.png
[7883501b-7e5c-4064-af0d-438a118acbf6]: /images/20220527/6d8a9638afa64a60ae9a97f5b1f5e76c.png
[7883501b-7e5c-4064-af0d-438a118acbf6 1]: http://images0.cnblogs.com/blog/641601/201508/211702057698597.png
[d481032e-ed23-46c2-9c5c-5f34e3193ef9]: /images/20220527/3917bc71e2ea4a86a4278f4da3803863.png
[d481032e-ed23-46c2-9c5c-5f34e3193ef9 1]: http://images0.cnblogs.com/blog/641601/201508/211702066751040.jpg
[142d481b-f4a3-4c23-b56d-cf3ec5b63a2e]: /images/20220527/27dec2df52a04b4a8c4fe4d3dbda4c85.png
[142d481b-f4a3-4c23-b56d-cf3ec5b63a2e 1]: http://images0.cnblogs.com/blog/641601/201508/211702077856713.png
[154748eb-cc14-48ee-b66f-cdcc26068cd1]: /images/20220527/c5ef240cb12647ecbd1e76e1666971f4.png
[154748eb-cc14-48ee-b66f-cdcc26068cd1 1]: http://images0.cnblogs.com/blog/641601/201508/211702089109156.png
[e0bcca41-a6e1-4a5c-b723-e0d721875acc]: /images/20220527/6d2faa08b5084975957f0362d062d7e2.png
[e0bcca41-a6e1-4a5c-b723-e0d721875acc 1]: http://images0.cnblogs.com/blog/641601/201508/211702102225358.png