你的位置:首页 > Java教程

[Java教程]JVM运行时内存结构


1.JVM内存模型

JVM运行时内存=共享内存区+线程内存区

1).共享内存区

共享内存区=持久带+堆

持久带=方法区+其他

堆=Old Space+Young Space

Young Space=Eden+S0+S1

(1)持久带

JVM用持久带(Permanent Space)实现方法区,主要存放所有已加载的类信息,方法信息,常量池等等。

可通过-XX:PermSize和-XX:MaxPermSize来指定持久带初始化值和最大值。

Permanent Space并不等同于方法区,只不过是Hotspot JVM用Permanent Space来实现方法区而已,有些虚拟机没有Permanent Space而用其他机制来实现方法区。

(2)堆

堆,主要用来存放类的对象实例信息。

堆分为Old Space(又名,Tenured Generation)和Young Space。

Old Space主要存放应用程序中生命周期长的存活对象;

Eden(伊甸园)主要存放新生的对象;

S0和S1是两个大小相同的内存区域,主要存放每次垃圾回收后Eden存活的对象,作为对象从Eden过渡到Old Space的缓冲地带(S是指英文单词Survivor Space)。

堆之所以要划分区间,是为了方便对象创建和垃圾回收,后面垃圾回收部分会解释。

2).线程内存区

线程内存区=单个线程内存+单个线程内存+.......

单个线程内存=PC Regster+JVM栈+本地方法栈

JVM栈=栈帧+栈帧+.....

栈帧=局域变量区+操作数区+帧数据区

在Java中,一个线程会对应一个JVM栈(JVM Stack),JVM栈里记录了线程的运行状态。

JVM栈以栈帧为单位组成,一个栈帧代表一个方法调用。栈帧由三部分组成:局部变量区、操作数栈、帧数据区。

(1)局部变量区

局部变量区,可以理解为一个以数组形式进行管理的内存区,从0开始计数,每个局部变量的空间是32位的,即4字节。

基本类型byte、char、short、boolean、int、float及对象引用等占一个局部变量空间,类型为short、byte和char的值在存入数组前要被转换成int值;long、double占两个局部变量空间,在访问long和double类型的局部变量时,只需要取第一个变量空间的索引即可,。

例如:

?
1
2
3
4
5
6
7
public static int runClassMethod(int i,long l,float f,double d,Object o,byte b) {   
    return 0;   
}   
            
public int runInstanceMethod(char c,double d,short s,boolean b) {   
    return 0;   
}



对应的局域变量区是:

runInstanceMethod的局部变量区第一项是个reference(引用),它指定的就是对象本身的引用,也就是我们常用的this,但是在runClassMethod方法中,没这个引用,那是因为runClassMethod是个静态方法。

(2)操作数栈

操作数栈和局部变量区一样,也被组织成一个以字长为单位的数组。但和前者不同的是,它不是通过索引来访问的,而是通过入栈和出栈来访问的。操作数栈是临时数据的存储区域。

例如:

?
1
2
3
int a= 100;
int b =5;
int c = a+b;



对应的操作数栈变化为:

从图中可以得出:操作数栈其实就是个临时数据存储区域,它是通过入栈和出栈来进行操作的。

PS:JVM实现里,有一种基于栈的指令集(Hotspot,oracle JVM),还有一种基于寄存器的指令集(DalvikVM,安卓 JVM),两者有什么区别的呢?

基于栈的指令集有接入简单、硬件无关性、代码紧凑、栈上分配无需考虑物理的空间分配等优势,但是由于相同的操作需要更多的出入栈操作,因此消耗的内存更大。 而基于寄存器的指令集最大的好处就是指令少,速度快,但是操作相对繁琐。

示例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.demo3;
 
public class Test {
 
    public static void foo() {
        int a = 1;
        int b = 2;
        int c = (a + b) * 5;
    }
 
    public static void main(String[] args) {
        foo();
    }
}



基于栈的Hotspot的执行过程如下:

基于寄存器的DalvikVM执行过程如下所示:

上述两种方式最终通过JVM执行引擎,CPU接收到的汇编指令是:

(3)帧数据区

 帧数据区存放了指向常量池的指针地址,当某些指令需要获得常量池的数据时,通过帧数据区中的指针地址来访问常量池的数据。此外,帧数据区还存放方法正常返回和异常终止需要的一些数据。

2.垃圾回收机制

1)、为什么要垃圾回收

JVM自动检测和释放不再使用的内存,提高内存利用率。 

Java 运行时JVM会执行 GC,这样程序员不再需要显式释放对象。 

2)、回收哪些内存区域

因为线程内存区随着线程的产生和退出而分配和回收,所以垃圾回收主要集中在共享内存区,也就是持久带(Permanent Space)和堆(Heap)

3)、如何判断对象已死 (对象标记)

(1)引用计数法

引用计数法就是通过一个计数器记录该对象被引用的次数,方法简单高效,但是解决不了循环引用的问题。比如对象A包含指向对象B的引用,对象B也包含指向对象A的引用,但没有引用指向A和B,这时当前回收如果采用的是引用计数法,那么对象A和B的被引用次数都为1,都不会被回收。JVM不是采用这种方法。

(2) 根搜索(可达性分析算法)

根搜索(可达性分析算法)可以解决对象循环引用的问题,基本原理是:通过一个叫“GC ROOT”根对象作为起点,然后根据关联关系,向下节点搜索,搜索路径叫引用链,也就是常说的引用。从“GC ROOT”根对象找不到任何一条路径与之相连的对象,就被判定可以回收,相当于这对象找不到家的感觉。

示例图:

GC会收集那些不是GC root且没有被GC root引用的对象。一个对象可以属于多个GC root。

GC root有几下种:

  • 虚拟机栈(栈帧中的本地变量表)中引用的对象

  • 方法区中类静态属性引用的对象

  • 方法区中常量引用的对象

  • 本地方法栈中JNI(native方法)引用的对象

  • 用于JVM特殊目的对象,例如系统类加载器等等

虽然有可达性分析算法来判定对象状态,但这并不是对象是否被回收的条件,对象回收的条件远远比这个复杂。无法通过GC ROOT关联到的对象,不都是立刻被回收。如果这个对象没有被关联到,而且没有被mark2标记,那么会进入一个死缓的阶段,被第一次标记(mark1),然后被放入一个F-Queue队列;如果这个对象被mark2标记了,那么这个对象将会被回收。

F-Queue队列由一个优先级较低的Finalizer线程去执行,其中的mark1对象等待执行自己的finalize()方法(JVM并不保证等待finalize()方法运行结束,因为finalize() 方法或者执行慢,或者死循环,会影响该队列其他元素执行)。执行mark1对象的finalize()方法,就会进行第二次标记(mark2)。以后的GC都会按这个逻辑执行“搜索,标记1,标记2”。

这一“标记”过程是后续垃圾回收算法的基础。

PS:

  • 如果在finalize() 方法体内,再次对本对象进行引用,那么对象就复活了。

  • finalize()方法只会被执行一次,所以对象只有一次复活的机会。

3)垃圾回收算法

垃圾回收算法主要有三种:

  • 标记-清除

  • 标记-复制

  • 标记-整理

这三种都有“标记”过程,这个标记过程就是上述的根搜索(可达性分析算法)。后面的“清除”、“复制”和“整理”动作,是具体的对象被回收的实现方式。

(1)标记-清除

通过根搜索(可达性分析算法)标记完成后,直接将标记为垃圾的对象所占内存空间释放。这种算法的缺点是内存碎片多。

虽然缺点明显,这种策略却是后两种策略的基础。正因为它的缺点,所以促成了后两种策略的产生。

动图:

(2)标记-复制

通过根搜索(可达性分析算法)标记完成后,将内存分为两块,将一块内存中保留的对象全部复制到另

一块空闲内存中。

动图:

这种算法的缺点是,可用内存变成了一半。怎么解决这个缺点呢?

JVM将堆(heap)分成young区和old区。young区包括eden、s0、s1,并且三个区之间的大小有一定比例。例如,按8:1:1分成一块Eden和两小块Survivor区,每次GC时,young区里,将Eden和S0中存活的对象复制到另一块空闲的S1中。

young区的垃圾回收是经常要发生的,被称为Minor GC(次要回收)。一般情况下,当新对象生成,并且在Eden申请空间失败时,就会触发Minor GC,对Eden区域进行GC,清除非存活对象,并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对Young space的Eden区进行,不会影响到Old space。因为大部分对象都是从Eden区开始的,同时Eden区不会分配的很大,所以Eden区的GC会频繁进行。因而,一般在这里需要使用速度快、效率高的算法,使Eden去能尽快空闲出来。

Minor GC主要过程:

a、新生成的对象在Eden区完成内存分配;

b、当Eden区满了,再创建对象,会因为申请不到空间,触发minorGC,进行young(eden+1survivor)区的垃圾回收。(为什么是eden+1survivor:两个survivor中始终有一个survivor是空的,空的那个被标记成To Survivor);

c、minorGC时,Eden不能被回收的对象被放入到空的survivor(也就是放到To Survivor,同时Eden肯定会被清空),另一个survivor(From Survivor)里不能被GC回收的对象也会被放入这个survivor(To Survivor),始终保证一个survivor是空的。(MinorGC完成之后,To Survivor 和 From Survivor的标记互换);

d、当做第3步的时候,如果发现存放对象的那个survivor满了,则这些对象被copy到old区,或者survivor区没有满,但是有些对象已经足够Old(通过XX:MaxTenuringThreshold参数来设置),也被放入Old区。(对象在Survivor区中每熬过一次Minor GC,年龄就增加1岁,当它的年龄增加到一定程度(默认为15岁)时,就会晋升到老年代中)

(3)标记-整理

old space也可以标记-复制策略吗?当然不行!

young space中的对象大部分都是生命周期较短的对象,每次GC后,所剩下的活对象数量不是很大。而old space中的对象大部分都是生命周期特别长的对象,即使GC后,仍然会剩下大量的活对象。如果仍然采用复制动作,回收效率会变得非常低。

根据old space的特点,可以采用整理动作。整理时,先清除掉应该清除的对象,然后把存活对象“压缩”到堆的一端,按顺序排放。

动图:

Old space(+Permanent Space)的垃圾回收是偶尔发生的,被称为Full GC(主要回收)。Full GC因为需要对整个堆进行回收,包括Young、Old和Perm,所以比Minor GC要慢,因此应该尽可能减少Full GC的次数。在对JVM调优的过程中,很大一部分工作就是对于FullGC的调节。

有如下原因可能导致Full GC:

  • 年老代(Tenured)被写满

  • 持久代(Perm)被写满

  • System.gc()被显示调用

  • 上一次GC之后Heap的各域分配策略动态变化

4)、垃圾收集器

垃圾收集算法是内存回收的理论基础,而垃圾收集器就是内存回收的具体实现。

堆(Heap)分代被目前大部分JVM所采用。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。一般情况下将堆区划分为old space和Young space,old space的特点是每次垃圾收集时只有少量对象需要被回收,而Young space的特点是每次垃圾回收时都有大量的对象需要被回收,那么就可以根据不同代的特点采取最适合的收集算法。

目前大部分垃圾收集器对于Young space都采取“标记-复制”算法。而由于Old space的特点是每次回收都只回收少量对象,一般使用的是“标记-整理”算法。

(1)Young Space上的GC实现:

Serial(串行): Serial收集器是最基本最古老的收集器,它是一个单线程收集器,并且在它进行垃圾收集时,必须暂停所有用户线程。Serial收集器是针对新生代的收集器,采用的是“标记-复制”算法。它的优点是实现简单高效,但是缺点是会给用户带来停顿。这个收集器类型仅应用于单核CPU桌面电脑。使用serial收集器会显着降低应用程序的性能。

ParNew(并行): ParNew收集器是Serial收集器的多线程版本,使用多个线程进行垃圾收集。

Parallel Scavenge(并行): Parallel Scavenge收集器是一个新生代的多线程收集器(并行收集器),它在回收期间不需要暂停其他用户线程,其采用的是“标记-复制”算法,该收集器与前两个收集器有所不同,它主要是为了达到一个可控的吞吐量。

(2)Old Space上的GC实现:

Serial Old(串行):Serial收集器的Old Space版本,采用的是“标记-整理”算法。这个收集器类型仅应用于单核CPU桌面电脑。使用serial收集器会显着降低应用程序的性能。

Parallel Old(并行):Parallel Old是Parallel Scavenge收集器的Old Space版本(并行收集器),使用多线程和“标记-整理”算法。

CMS(并发):CMS(Current Mark Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器,它是一种并发收集器,采用的是"标记-清除"算法。

(3).G1

G1(Garbage First)收集器是JDK1.7提供的一个新收集器,G1收集器基于“标记-整理”算法实现,也就是说不会产生内存碎片。还有一个特点之前的收集器进行收集的范围都是整个新生代或老年代,而G1将整个Java堆(包括新生代,老年代)。

3.JVM参数

1).堆

-Xmx:最大堆内存,如:-Xmx512m

-Xms:初始时堆内存,如:-Xms256m

-XX:MaxNewSize:最大年轻区内存

-XX:NewSize:初始时年轻区内存.通常为 Xmx 的 1/3 或 1/4。新生代 = Eden + 2 个 Survivor 空间。实际可用空间为 = Eden + 1 个 Survivor,即 90%

-XX:MaxPermSize:最大持久带内存

-XX:PermSize:初始时持久带内存

-XX:+PrintGCDetails。打印 GC 信息

 -XX:NewRatio 新生代与老年代的比例,如 –XX:NewRatio=2,则新生代占整个堆空间的1/3,老年代占2/3

 -XX:SurvivorRatio 新生代中 Eden 与 Survivor 的比值。默认值为 8。即 Eden 占新生代空间的 8/10,另外两个 Survivor 各占 1/10

2).栈

-xss:设置每个线程的堆栈大小. JDK1.5+ 每个线程堆栈大小为 1M,一般来说如果栈不是很深的话, 1M 是绝对够用了的。

3).垃圾回收

4).JVM  client模式和server模式

Java_home/bin/java命令有一个-server和-client参数,该参数标识了JVM以server模式或client模式启动。

JVM Server模式与client模式启动,最主要的差别在于:-Server模式启动时,速度较慢,但是一旦运行起来后,性能将会有很大的提升。当虚拟机运行在-client模式的时候,使用的是一个代号为C1的轻量级编译器, 而-server模式启动的虚拟机采用相对重量级,代号为C2的编译器. C2比C1编译器编译的相对彻底,,服务起来之后,性能更高。

(1)查看当前JVM默认启动模式

java -version 可以直接查看出默认使用的是client还是 server。

(2)JVM默认启动模式自动侦测

从JDK 5开始,如果没有显式地用-client或者-server参数,那么JVM启动时,会根据机器配置和JDK的版本,自动判断该用哪种模式。

  • the definition of a server-class machine is one with at least 2 CPUs and at least 2GB of physical memory.

  • windows平台,64位版本的JDK,没有提供-client模式,直接使用server模式。

(3).通过配置文件,改变JVM启动模式

两种模式的切换可以通过更改配置(jvm.cfg配置文件)来实现:

32位的JVM配置文件在JAVA_HOME/jre/lib/i386/jvm.cfg,

64位的JVM配置文件在JAVA_HOME/jre/lib/amd64/jvm.cfg, 目前64位只支持server模式。

例如:

32位版本的JDK 5的jvm.cfg文件内容:

?
1
2
3
4
5
6
-client KNOWN
-server KNOWN
-hotspot ALIASED_TO -client
-classic WARN
-native ERROR
-green ERROR



64位版本的JDK 7的jvm.cfg文件内容:

?
1
2
3
4
5
6
-server KNOWN
-client IGNORE
-hotspot ALIASED_TO -server
-classic WARN
-native ERROR
-green ERROR



 

4.堆 VS 栈

JVM栈是运行时的单位,而JVM堆是存储的单位。

JVM栈代表了处理逻辑,而JVM堆代表了数据。

JVM堆中存的是对象。JVM栈中存的是基本数据类型和JVM堆中对象的引用。

JVM堆是所有线程共享,JVM栈是线程独有。

PS:Java中的参数传递是传值呢?还是传址?

我们都知道:C 语言中函数参数的传递有:值传递,地址传递,引用传递这三种形式。但是在Java里,方法的参数传递方式只有一种:值传递。所谓值传递,就是将实际参数值的副本(复制品)传入方法内,而参数本身不会受到任何影响。

要说明这个问题,先要明确两点:

1.引用在Java中是一种数据类型,跟基本类型int等等同一地位。

2.程序运行永远都是在JVM栈中进行的,因而参数传递时,只存在传递基本类型和对象引用的问题。不会直接传对象本身。

在运行JVM栈中,基本类型和引用的处理是一样的,都是传值。如果是传引用的方法调用,可以理解为“传引用值”的传值调用,即“引用值”被做了一个复制品,然后赋值给参数,引用的处理跟基本类型是完全一样的。但是当进入被调用方法时,被传递的这个引用值,被程序解释(或者查找)到JVM堆中的对象,这个时候才对应到真正的对象。如果此时进行修改,修改的是引用对应的对象,而不是引用本身,即:修改的是JVM堆中的数据。所以这个修改是可以保持的了。

例如:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.demo3;
 
public class DataWrap {
    public int a;
    public int b;
}
 
package com.demo3;
 
public class ReferenceTransferTest {
    public static void swap(DataWrap dw) {
        int tmp = dw.a;
        dw.a = dw.b;
        dw.b = tmp;
    }
 
    public static void main(String[] args) {
        DataWrap dw = new DataWrap();
        dw.a = 6;
        dw.b = 9;
        swap(dw);
    }
}



对应的内存图:

 

附: