JVM 深入浅出

最新推荐文章于 2022-07-26 10:57:57 发布

洛神夫

最新推荐文章于 2022-07-26 10:57:57 发布

阅读量2.2k

点赞数

本文链接：https://blog.csdn.net/luoshenfu001/article/details/9848947

版权

关于JVM 内存，本博还有 Java GC 和 JVM 调优和 Java Memory Leak详解两篇文章。

每个JVM都有两种机制，一个是装载具有合适名称的类(类或是接口)，叫做类装载子系统；另外的一个负责执行包含在已装载的类或接口中的指令，叫做运行引擎。每个JVM又包括方法区、堆、Java栈、程序计数器和本地方法栈这五个部分。

程序计数器（Program Counter Register）

在一个Java方法运行时，Program counter Register总是存放着下一条要执行的语句的节码指令的地址。每个线程都有自己的PC寄存器，各条线程之间互不影响，内存在任意时刻，一条JVM线程只会执行一个方法的代码。BTW, 如果该方法是native，那PC寄存器的值是undefined。此区域是唯一一不会抛出OutOfMemoryError区域。

Java虚拟机栈（Java Virtual Machine Stack）

每启动一个线程，JVM都会为它分配一个Java栈，即线程私有，用于存放方法中的局部变量，操作数以及异常数据等。当线程调用某个方法时，JVM会根据方法区中该方法的字节码组建一个栈帧(Stack Frame)，并将该栈帧压入Java栈中，方法执行完毕时，JVM会弹出该栈帧并释放掉。

Stack大小可动态扩展，尝试扩展时无法申请到足够的内存时抛出OutOfMemoryError；如果线程请求的栈深度大于虚拟机所允许的深度将抛出StackOverflowError；

【栈帧】栈帧有三部分构成：局部变量区、操作数栈和帧数据区。在编译器编译Java代码时，就已经在字节码中为每个方法都设置好了局部变量区和操作数栈的数据和大小。并在JVM首次加载方法所属的Class文件时，就将这些数据放进了方法区。因此在线程调用方法时，只需要根据方法区中的局部变量区和操作数栈的大小来分配一个新的栈帧的内存大小，并堆入Java栈。

局部变量区：用来存放方法中的所有局部变量值，包括传递的参数。这些数据会被组织成以一个字长(32bit或64bit)为单位的数组结构(以索引0开始)中。其中类型为int,float,reference(引用类型，记录对象在堆中地址)和returnAddress(一种JVM内部使用的基本类型)的值占用1个字长，而byte,char和shot会扩大成1个字长存储，long，double则使用2个字长。

操作数栈：用来在执行指令的时候存储和使用中间结果数据。

帧数据区：常量池的解析，正常方法返回以及异常派发机制的信息数据都存储在其中。

本地方法栈（Native Method Stack）

本地方法栈与虚拟机栈作用相似，后者为虚拟机执行Java方法服务，而前者为虚拟机用到的Native方法服务。

虚拟机规范对于本地方法栈中方法使用的语言，使用方式和数据结构没有强制规定，甚至有的虚拟机（比如HotSpot）直接把二者合二为一。

Java堆（JavaHeap）

虚拟机管理的内存中最大的一块，同时也是被所有线程所共享的，它在虚拟机启动时创建，这货存在的意义就是存放对象实例，几乎所有的对象实例以及数组都要在这里分配内存。这里面的对象被自动管理，也就是俗称的GC（Garbage Collector）所管理。一般来说，堆的划分有年轻代（又分为一个伊甸区和两个存活区），年老代和持久代，其中持久代在位置上属于方法区。

Java堆的容量可动态扩展（-Xms和-Xmx），内存不需要物理上连续，可抛出OutOfMemoryError。

堆中对象存储的是该对象以及对象所有超类的实例数据(实例数据是指属于对象的非静态数据)，比如下面的类型：

class X{

private int data;

private static int stcdata=0;

public X(int d){

this.data=d;

}

X x1=new X(100);

X x2=new X(200);

这样在堆中开辟了两个对象x1和x2的内存空间。其中x1中的一个实例数据data=100，而x2的data=200。但是这两个对象中都没有stcdata这样的数据，这个静态数据存储在的方法区中。

此外，堆中对象还必须有指向方法区中的类信息数据(见方法区)。为什么需要这个信息呢？因为当程序在运行时需要对象转型，那么JVM必须检查当前对象所属类型及父类的信息。以判断转型是否是合法的，而这一点也是instanceof操作符实现的基础。

其中一个对象的引用可能在整个运行时数据区中的很多地方存在，比如Java栈，堆，方法区等。

堆中对象还应该关联一个对象的锁数据信息以及线程的等待集合。这些都是实现Java线程同步机制的基础（即实现线程的同步所需要的信息在堆中，因为栈是独属于一个线程的，而堆是可以被所有线程共享的）。但实际上很多具体实现中并不在对象自身内部保存一个指向锁数据的指针。而只有当第一次需要加锁的时候才分配对应锁数据。另外，每个对象都会从Object中继承三个Object方法(wait、notify、notifyAll)，当某个线程在一个对象上调用了等待方法时。JVM就会阻塞这个线程，并把这个线程放在该对象的等待集合中。直到另外一个线程在该对象上调用了notify/notifyAll，JVM才会在等待集合中唤醒一个或全部的等待线程。

因此，也就出现了，用改变公共数据区对象的锁的方法是通过公共数据区对象本身来调用，和线程对象是没有关系的。

事实上，每一个同步锁lock下面都挂了几个线程队列，包括就绪（Ready）队列，等待（Waiting）队列等。当线程A因为得不到同步锁lock，从而进入的是lock.ReadyQueue(就绪队列)，一旦同步锁不被占用，JVM将自动运行就绪队列中的线程而不需要任何notify()的操作。但是当线程A被wait()了，那么将进入lock.WaitingQuene(等待队列)，同时如果占据的同步锁也会放弃。而此时如果同步锁不唤醒等待队列中的进程(lock.notify())，这些进程将永远不会得到运行的机会。就绪队列和等待队列有很大的不同，这一点要牢记。Obj.wait()和obj.notify()方法必须放在Obj的synchronized块中使用。

方法区（Method Area）

跟堆一样是被各个线程共享的内存区域，用于存储以被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

方法区在虚拟机启动的时候创建，大小可扩展，像堆一样在内存空间可以不连续，可抛出OutofMemorryError。

当JVM使用类装载器定位Class文件，并将其输入到内存中时。会提取Class文件的类型信息，并将这些信息存储到方法区中。同时放入方法取中的还有该类型中的类静态变量。下面我们具体看看需要存储哪些信息？

类全名，类接口名，类修饰符（pubic,final, abstract等）。
类常量池。常量池是类所用常量的一个有序集合，包括直接常量（基本类型，String）和对其他类型、字段、方法的符号引用。之所以是符号引用而不是像c语言那样，编译时直接指定其他类型，是因为java是动态绑定的，只有在运行时根据某些规则才能确定具体依赖的类型实例，这正是java实现多态的基础。 For each type it loads, a Java Virtual Machine must store a constant pool.A constant pool is an ordered set of constants used by the type, including literals (string, integer, and floating point constants) and symbolic references to types, fields, and methods. Entries in the constant pool are referenced by index, much like the elements of an array. Because it holds symbolic references to all types, fields, and methods used by a type, the constant pool plays a central role in the dynamic linking of Java programs. 为啥常量池中含有对方法，字段及其他类型的符号引用呢？因为class文件并不包含其内部组件最终内存布局的信息，因此类，字段和方法并不能被class文件中的字节码直接引用。Java虚拟机从常量池获得符号引用，然后在运行时解析引用项的实际地址。
类中字段信息：字段名，类型，即修饰符(public, private, protected, static, final, volatile,transient的某个子集)。还有，这些字段在类或者接口中的声明顺序。
方法信息：方法名，返回类型，修饰符，参数类型，异常表，方法的字节码，操作数栈及局部变量的大小
类静态变量。
如果该类是被自定义ClassLoader装载的，还要保存对该ClassLoader类的引用。
指向java.lang.Class类的引用。对于每一个被装载的类型，虚拟机都会相应的为它创建一个java.lang.Class类的实例，而且虚拟机还必须以某种方式把这个实例和存储在方法区中的类型信息关联起来。这就可以在程序运行时查看某个加载进内存的类的当前状态信息。也就是反射机制实现的根本。
方法表。为了能快速定位到类型中的某个方法。JVM对每个装载的类型都会建立一个方法表，用于存储该类型对象可以调用的方法的直接引用，这些方法就包括从超类中继承来的。而这张表与Java动态绑定机制(参见《java动态绑定机制实现多态：http://hxraid.iteye.com/blog/428891》)的实现是密切相关的。

方法区是多线程共享的。也就是当虚拟机实例开始运行程序时，边运行边加载进Class文件。不同的Class文件都会提取出不同类型信息存放在方法区中。同样，方法区中不再需要运行的类型信息会被垃圾回收线程丢弃掉。

这里有一个小例子，来说明堆，栈和方法区之间的关系的

public class Test2 {

public static void main(String[] args) {

publicTest2 t2 = new Test2();

//JVM将Test2类信息加载到方法区,new Test2()实例保存在堆区,Test2引用保存在栈区，在栈中执行时才创建对象

}

运行时常量池（Runtime Constant Pool）

它是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述等信息外，还有一项信息是常量池（ConstantPool Table），用于存放编译期生成的各种字面量和符号引用，这部分内容将在类加载后存放到方法区的运行时常量池中。常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。

 
 String s0=”kvill”;  
String s1=”kvill”;  
String s2=”kv” + “ill”;  
System.out.println( s0==s1 );  
System.out.println( s0==s2 );

结果为：

 
 true   
true

首先，我们要知道Java会确保一个字符串常量只有一个拷贝。

因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。

所以我们得出s0==s1==s2;

用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

看例2：

 
 String s0=”kvill”;  
String s1=new String(”kvill”);  
String s2=”kv” + new String(“ill”);  
System.out.println( s0==s1 );  
System.out.println( s0==s2 );  
System.out.println( s1==s2 );

结果为：

 
 false  
false  
false

例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。

4. String.intern()：

再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了

例3：

 
 String s0= “kvill”;  
String s1=new String(”kvill”);  
String s2=new String(“kvill”);  
System.out.println( s0==s1 );  
System.out.println( “**********” );  
s1.intern();  
s2=s2.intern(); //把常量池中“kvill”的引用赋给s2  
System.out.println( s0==s1);  
System.out.println( s0==s1.intern() );  
System.out.println( s0==s2 );

结果为：

 
 false  
**********  
false //虽然执行了s1.intern(),但它的返回值没有赋给s1  
true //说明s1.intern()返回的是常量池中”kvill”的引用  
true

最后我再破除一个错误的理解：

有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

看例4：

 
 String s1=new String("kvill");  
String s2=s1.intern();  
System.out.println( s1==s1.intern() );  
System.out.println( s1+" "+s2 );  
System.out.println( s2==s1.intern() );

结果：

 
 false 
kvill kvill  
true

在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

s1==s1.intern()为false说明原来的“kvill”仍然存在；

s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

5. 关于equals()和==:

这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

6. 关于String是不可变的

这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;
就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。

Java虚拟机对Class文件的每一部分（自然也包括常量池）的格式都有严格的规定，每一个字节用于存储哪种数据都必须符合规范上的要求，这样才会被虚拟机认可、装载和执行。但对于运行时常量池，Java虚拟机规范没有做任何细节的要求，不同的提供商实现的虚拟机可以按照自己的需要来实现这个内存区域。不过，一般来说，除了保存Class文件中描述的符号引用外，还会把翻译出来的直接引用也存储在运行时常量池中。

运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只能在编译期产生，也就是并非预置入Class文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用得比较多的便是String类的intern()方法。为了实现实例间的互相调用，方法区和heap必须是可共享的。既然运行时常量池是方法区的一部分，自然会受到方法区内存的限制，当常量池无法再申请到内存时会抛出OutOfMemoryError异常

关于String.intern()方法：public Stringintern() 返回字符串对象的规范化表示形式。

一个初始时为空的字符串池，它由类 String，而不是对象，私有地维护。

当调用 intern方法时，如果池已经包含一个等于此 String对象的字符串（该对象由equals(Object)方法确定），则返回池中的字符串。否则，将此 String对象添加到池中，并且返回此 String对象的引用。它遵循对于任何两个字符串 s和 t，当且仅当 s.equals(t)为 true时，s.intern() == t.intern()才为 true。所有字面值字符串和字符串赋值常量表达式都是内部的。

可以看下面一个范例：

1String str1 ="a";
2String str2 ="b";
3String str3 ="ab";
4String str4 =str1+str2;
5String str5 =newString("ab");
6
7System.out.println(str5.equals(str3));
8System.out.println(str5 ==str3);
9System.out.println(str5.intern() ==str3);
10System.out.println(str5.intern() ==str4);

得到的结果：

true

false

true

false

为什么会得到这样的一个结果呢？我们一步一步的分析。首先str1,str2和str3都在常量池中了。

第一、str5.equals(str3)这个结果为true，不用太多的解释，因为字符串的值的内容相同。

第二、str5 == str3对比的是引用的地址是否相同，由于str5采用new String方式定义的，所以地址引用一定不相等。所以结果为false。

第三、当str5调用intern的时候，会检查字符串池中是否含有该字符串。由于str3已经进入字符串池中，所以会得到相同的引用。

第四，当str4 = str1 + str2后，str4的值也为”ab”，但是为什么这个结果会是false呢？先看下面代码：

1String a =newString("ab");
2String b =newString("ab");
3String c ="ab";
4String d ="a"+"b";
5String e ="b";
6String f ="a"+e;
7
8System.out.println(b.intern() ==a);
9System.out.println(b.intern() ==c);
10System.out.println(b.intern() ==d);
11System.out.println(b.intern() ==f);
12System.out.println(b.intern() ==a.intern());

运行结果：

false

true

false

true

由运行结果可以看出来，b.intern() != a和b.intern() = c可知，（1）采用new创建的字符串对象不进入字符串池，并且通过b.intern() = d和b.intern() != f可知，（2）字符串相加的时候，都是静态字符串的结果会添加到字符串池，（3）如果其中含有变量（如f中的e）则不会进入字符串池中，所以上上题中为啥str5.intern()!=str4了。但是字符串一旦进入字符串池中，就会先查找池中有无此对象。如果有此对象，则让对象引用指向此对象。如果无此对象，则先创建此对象，再让对象引用指向此对象。

当研究到这个地方的时候，突然想起来经常遇到的一个比较经典的Java问题，就是对比equal和==的区别，当时记得老师只是说“==”判断的是“地址”，但是并没说清楚什么时候会有地址相等的情况。现在看来，在定义变量的时候赋值，如果赋值的是静态的字符串，就会执行进入字符串池的操作，如果池中含有该字符串，则返回引用。

执行下面的代码：

1String a ="abc";
2String b ="abc";
3String c ="a"+"b"+"c";
4String d ="a"+"bc";
5String e ="ab"+"c";
6
7System.out.println(a ==b);
8System.out.println(a ==c);
9System.out.println(a ==d);
10System.out.println(a ==e);
11System.out.println(c ==d);
12System.out.println(c ==e);

运行的结果：

true

运行的结果刚好验证了我刚才的猜想。

直接内存（Direct Memory）

直接内存（Direct Memory）并不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用，而且也可能导致OutOfMemoryError异常出现。

JDK1.4加的NIO中，ByteBuffer有个方法是allocateDirect(intcapacity)，这是一种基于通道（Channel）与缓冲区（Buffer）的I/O方式，它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆里面的DirectByteBuffer对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能，因为避免了在Java堆和Native堆中来回复制数据。

显然，本机直接内存的分配不会受到Java堆大小的限制，但是，既然是内存，则肯定还是会受到本机总内存（包括RAM及SWAP区或者分页文件）的大小及处理器寻址空间的限制。服务器管理员配置虚拟机参数时，一般会根据实际内存设置-Xmx等参数信息，但经常会忽略掉直接内存，使得各个内存区域的总和大于物理内存限制（包括物理上的和操作系统级的限制），从而导致动态扩展时出现OutOfMemoryError异常。

http://blog.csdn.net/smcwwh/article/details/6729622

★执行引擎

运行Java的每一个线程都是一个独立的虚拟机执行引擎的实例。从线程生命周期的开始到结束，他要么在执行字节码，要么在执行本地方法。一个线程可能通过解释或者使用芯片级指令直接执行字节码，或者间接通过JIT执行编译过的本地代码。

指令集：实际上，Class文件中方法的字节码流就是有JVM的指令序列构成的。每一条指令包含一个单字节的操作码，后面跟随0个或多个操作数。

Java虚拟机指令集关注的中心是操作数栈和局部变量集合。我们可以看看下面一组指令在执行引擎中执行的过程：

Jvm助记指令代码

1 iload_0 // 把存储在局部变量区中索引为0的整数压入操作数栈。

2 iload_1 // 把存储在局部变量区中索引为1的整数压入操作数栈。

3 iadd // 从操作数栈中弹出两个整数相加，在将结果压入操作数栈。

4 istore_2 // 从操作数栈中弹出结果

很显然，上面的指令反复用到了Java栈中的某一个方法栈帧。实际上执行引擎运行Java字节码指令很多时候都是在不停的操作Java栈，也有的时候需要在堆中开辟对象以及运行系统的本地指令等。但是Java栈的操作要比堆中的操作要快的多，因此反复开辟对象是非常耗时的。这也是为什么Java程序优化的时候，尽量减少new对象。

下面将会是很有趣的过程，我们用一段代码来生动的展现JVM是如何运行这段程序的。

通过编译器将下面的代码编译成edu/hr/jvm/Test.class和 edu/hr/jvm/bean/Act.class。然后开始启动JVM：

[java]view plaincopy

5 //源代码Test.java

6 package edu.hr.jvm;

8 import edu.hr.jvm.bean;

9 publicclass Test{

10 public staticvoidmain(String[] args){

11 Act act=newAct();

12 act.doMathForever();

13 }

14 }

16 //源代码Act.java

17 package edu.hr.jvm.bean;

19 publicclass Act{

20 publicvoiddoMathForever(){

21 int i=0;

22 for(;;){

23 i+=1;

24 i*=2;

25 }

26 }

27 }

(1) 首先OS会创建一个JVM实例(进行必要的初始化工作，比如初始启动类装载器，初始运行时内存数据区等)。

(2) 然后通过ClassLoader加载Test.class，并提取该类的字节码存放在方法区中，其中在常量池中有一个符号引用"Act" (注意：这个引用目前还没有真正的类信息的内存地址)。【并非将所有的类都加载进方法区，在用的时候才进行加载哦，在未被加载尽量的类即被引用类，被加载进来之前，在常量池中会有它的一个符号引用，即它引用的类全类名，未指向真正的地址。具体可以参看本文中关于方法区-常量池的介绍】

(3) 接着JVM开始从Test类的main字节码处开始解释执行。在运行之前，会在Java栈中组建一个main方法的栈帧。

(4) 现在可以开始执行main方法的第一条指令——JVM需要为常量池的第一项的类(符号引用Act)分配内存空间，但是Act类此时还没有加载进JVM。

(5) JVM加载进Act.class，并提取Act类信息放入方法区中，然后以一个直接指向方法区Act类信息的直接引用替换开始在常量池中的符号引用"Act"，这个过程就是常量池解析。

(6) 此时JVM可以根据方法区中的Act类信息，在堆中开辟一个Act类对象act。

(7) 接着开始执行main方法中的第二条指令调用doMathForever。这个可以通过堆中act对象所指的方法表中查找，然后定位到方法区中的Act类信息中的doMathForever方法字节码。在运行之前，仍然要组建一个doMathForever栈帧压入Java栈。(注意：JVM会根据方法区中doMathForever的字节码来创建栈帧的局部变量区和操作数栈的大小)

(8) 接下来JVM开始解释运行Act.doMathForever字节码的内容了。下面我们详细的描述一下这个JVM的运行过程：

●我们首先看一下doMathForever方法的字节码在方法区中的指令，其中bytecode是指令的二进制编码，mnemonic是指令助记符，pc为程序计数器 (指向当前运行指令的下一条)，offset为指令存放在方法区中的地址偏移。

●然后在上面的图Java栈中已经显示出了doMathForever方法的栈帧，其中比较重要的两个部分是局部变量区和操作数栈。而此时在运行指令之前，局部变量区中只有一个整型i的存储位置(1个字长)。而操作数栈中还没有被创建了2个字长的大小(存储大小是帧栈创建的时候由方法区中的数据确定的)。

局部变量区

index hex value value

(变量i) 0

optop: 0 操作数栈

offset hex value value

optop-> 0

● 下面运行每一条指令后，看一下局部变量区和操作数栈的变化：

①指令[iconst_0] 将int类型变量的数据0压入操作数栈。

局部变量区操作数栈