JVM
什么是JVM?
JVM是java虚拟机的缩写,本质上是一个程序,能识别.class字节码文件(.java文件编译后产生的二进制代码),并且能够解析它的指令,最终调用操作系统上的函数,完成我们想要的操作。
关于java语言的跨平台性(一次编译,多次运行),就是应为JVM,可以把它想象出一个抽象层,运行在操作系统之上的,与硬件没有直接的交互,只要这个抽象层JVM正确执行了.class文件,就能运行在各种操作系统之上了。
介绍几个术语:
- JDK:java开发工具包,JDK=JRE+javac/java/jar等指令工具
- JRE:java运行环境,JRE=JVM+java基本类库
JVM体系结构
java虚拟机主要分为五大模块:
- 类加载器
- 运行时数据区
- 执行引擎
- 本地方法接口
- 垃圾收集模块
方法区是一种特殊的堆,栈里面不回有垃圾,用完就弹出了,否则阻塞了main方法。垃圾几乎都在堆里,所以JVM性能调优%99都针对与堆。
目前最常用的JVM是Sun公司的HotSpot,此外还有BEA公司的JRockit和IBM公司的J9 VM。
类加载器
作用:加载.class字节码文件。
new一个对象的过程
//运行时,JVM将Test的信息放入方法区
public class Test{
public static void main(String[] args){
Student s1 = new Student("Tom");//引用放在栈里,具体的实例放在堆里
Student s2 = new Student("Jerry");
Student s3 = new Student("Victor");
//三个hashCode是不同的,因为是三个不同的对象,对象是具体的
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
//class1,class2,class3为同一个对象,因为这是类模版,模版是抽象的
Class<? extends Stedent> class1 = s1.getClass();
Class<? extends Stedent> class2 = s2.getClass();
Class<? extends Stedent> class3 = s3.getClass();
System.out.println(class1.hashCode());
System.out.println(class2.hashCode());
System.out.println(class3.hashCode());
}
}
- 首先Class Loader读取字节码文件,加载初始化生成Student模版类。
- 通过Student模版类new出三个对象。
类加载器的类别
public class Test{
public static void main(String[] args){
Student s = new Student("Tom");
Class<? extends Student> c = s.getClass();
ClassLoader classLoader = c.getClassLoader();
System.out.println(classLoader);//APPClassLoader
System.out.println(classLoader.getParent());//PlatformClassLoader
System.out.println(classzLader.getParent().getParent());//null,获取不到(C++写的)
}
}
根据返回结果,级别从高到低有三种加载器:
- 启动类(根)加载器:BootStrapClassLoader。
- c++编写的,加载java核心库,构造拓展类加载器和应用程序加载器
- 根加载器加载拓展类加载器,并且将拓展类加载器的父加载器设置为根加载器
- 然后在加载应用程序加载器,应将应用程序的加载器的父加载器设置为拓展类加载器
- 由于根加载器涉及到虚拟机本地实现的细节,我们无法直接获取到启动类加载器的引用,这就是上面第三个结果为null的原因
- 加载文件存在于/jdk/jdk1.8/jre/lib/rt.jar
- 拓展类加载器:PlatformClassLoader
- java编写,加载扩展库,开发者可以直接使用标准扩展类加载器
- java9之前称为ExtClassLoader
- 加载文件存在于…/lib/ext
- 应用程序加载器:AppClassLoader
- Java编写,加载程序所在的目录,是java默认的类加载器
- 用户自定义加载器:CustomeClassLoader
- java编写,用户自定义的类加载器,可加载指定路径的class文件
实际上,这些加载器的区别就是加载不同范围或不同路径的.class文件。
双亲委派机制
双亲委派机制是类加载器收到类加载的请求,会将这个请求向上委托给父类加载器去完成,一直向上委托,直到根加载器BootStrapClassLoader。根加载器检查是否能够加载当前类,能加载就结束,使用当前类加载器,否则就抛出异常,通知子加载器进行加载。
举个例子,我们重写java.lang包下的String类:
package java.lang;
public class String{
public String toString(){
return "xing";
}
public static void main(String[] args){
new String().toString;
}
}
//Error:(1,1) java:程序包已存在于另一个模块中:java:base
我们会发现报错,这就是双亲委派机制起的作用,当类加载器委托到根加载器的时候,String类已经被根加载器加载过一遍了,所以不会再加载,从一定程度上防止了危险代码的植入。
作用总结:
- 防止重复加载同一个.class,通过不断委托父加载器直到根加载器,如果父加载器加载过了,就不用再加载一遍,保证数据安全。
- 保证系统核心.class不被篡改。通过委托方式,不会去篡改核心.class,即使篡改也不会去加载,即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个class对象,这样保证了class执行安全。
沙箱安全机制
什么是沙箱
java安全模型的核心就是java沙箱(sandbox)。
沙箱是一个限制程序运行的环境。沙箱机制就是将java代码限定在虚拟机特定的运行范围中,并且严格限制代码对本地系统资源的访问,通过这样的措施来保证对代码的有效隔离,防止对本地系统的破坏。
沙箱主要限制系统资源访问,包括CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也不一样。
所有的java程序运行都可以指定沙箱,可以定制安全策略。
java中安全模型的演进
在java中将执行程序分为本地代码和远程代码两种:本地代码可信任,可以访问一起本地资源。远程代码不可信任,在早期的java实现中,安全依赖于沙箱机制。
如此严格的安全机制也给程序的功能扩展带来障碍,比如当用户希望远程代码访问本地系统文件的时候,就无法实现。因此在后续的java1.1中,针对安全机制做了改进,增加了安全策略,允许用户指定代码对本地资源的访问权限。
在java1.2版本中,再次改进了安全机制,增加了代码签名。不论本地代码或者远程代码,都会按照用户的安全策略设定,由类加载器加载到虚拟机中权限不同的运行空间,来实现差异化的代码执行权限控制。
当前最新的安全机制实现,则引入了域(Domain)的概念。虚拟机会把所有的代码加载到不同的系统域和应用域,系统域部分专门负责与关键资源进行交互,应用域部分则通过系统域的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域对应不一样的权限,存在于不同域中的类文件就具有了当前域的全部权限。
组成沙箱的基本组件
-
字节码校验器(bytecode verifier)
确保java类文件遵循java语言规范。这样可以帮助java程序实现内存保护。但并不是所有的类文件都会经过字节码校验,比如核心类。
-
类装载器(class loader)
类装载器在3个方面对java沙箱起作用
- 防止恶意代码去干涉善意的代码
- 守护了被信任的类库边界
- 将代码归入保护域,确定了代码可以进行哪些操作。
虚拟机为不同的类加载器载入的类提供不同的命名空间,命名空间由一系列唯一的名称组成,每一个被装载的类将有一个名字,这个命名空间是由java虚拟机为每一个类装载器维护的,他们互相之间甚至不可见。
-
存取控制器(access controller):存取控制器可以控制核心API对操作系统的存取权限,而这个控制的策略设定可以由用户指定。
-
安全管理器(security manager):是核心API和操作系统之间的主要接口。实现权限控制,比如存取控制器优先级高。
-
安全软件包(security package):java.security下的类和扩展包下的类,允许用户为自己的应用增加新的安全特性,包括安全提供者、消息摘要、数字签名、加密、鉴别。
Native本地方法接口
JNI:java native interface
本地接口的作用是融合不同的编程语言为java所用,它的初衷是融合C/C++程序。
凡是带native关键字的,就说明java的作用范围达不到了,会去调用底层c语言库,进入本地方法栈,调用本地方法接口JNI,拓展java的使用,融合不同的语言为java所用。
java诞生的时候C/C++横行,为了立足,必须要能够调用C/C++程序,于是在内存区域中专门开辟了一块标记区域:Native Method Stack,登记Native方法,最终在执行引擎上执行的时候通过JNI加载本地方法库中的方法。目前该方法的使用越来越少了,除非是与硬件有关的应用,比如通过java程序驱动打印机或者java系统管理生产设备,在企业级应用中已经比较少见。因为现在的异构领域间通信很发达,比如可以用Socket通信,也可以使用Web Service等。
运行时数据区
PC寄存器(Program Counter Register)
每个线程都有一个程序计数器,是线程私有的,就是一个指针,指向方法区中的方法字节码(用来存储指向像一条指令的地址,也即将要执行的指令代码),在执行引擎读取下一条指令,是一个非常小的内存空间,几乎可以忽略不计。
方法区(Method Area)
方法区与java堆一样,是各个线程共享的内存区域,用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器遍以后的代码等数据。虽然java虚拟机规范把方法区描述为堆的一个逻辑部分,但是它却有一个别名Non-Heap,因此实际上应该和堆区分开。
方法区中有啥?
- 静态变量(static)
- 常量(final)
- 类信息(构造方法,接口定义)
- 运行时的常量池
创建对象内存分析
public class Person{
int age;
String name = "xing";
public Person(int age, String name){
this.age = age;
this.name = name;
}
public static void main(String[] agrs){
Person s1 = new Person(18,"Tom");
}
}
/*
创建一个对象时,方法区中会生成对应类的抽象模版;还有对应的常量池、静态变量、类信息、常量。
我们通过类模版去new对象的时候,堆中存放实例对象,栈中存放对象的引用,每个对象对应一个地址指向堆中相同地址的实例对象。
*/
栈
主管程序的运行,生命周期和线程同步。线程结束,栈内存就释放了,不存在垃圾回收。栈中存放8大基本类型,对象引用,实例的方法。
栈运行的原理
栈表示java方法执行的内存模型,每调用一个方法就会为每个方法生成一个栈帧(Stack Frame),每个方法被调用的完成的过程,都对应一个栈帧从虚拟机栈上入栈和出栈的过程。程序正在执行的方法一定在栈的顶部。
堆栈溢出(StackOverflowError)
public class Test{
public static void main(String[] args){
new Test().a();
}
public void a(){
b();
}
public void b(){
a();
}
}
//最开始,main()方法压入栈中,然后执行a(),a()押入栈中,在调用b(),b()押入栈栈中,以此往复,最终导致栈溢出
堆
一个JVM只有一个堆内存(栈是线程级的),堆内存的大小是可以调节的,堆中存放实例化的对象。
堆内存详解
-
年轻代
对象的诞生、成长甚至死亡的区
- Eden Space(伊甸园区):所有对象都是在此new出来的
- Survivor Space(幸存区)
- 幸存0区(From Space),动态的From和To会互相交换
- 幸存1区(To Space)
Eden区占大容量,Survivor两个区占小容量,默认比例是8:1:1。
-
老年代
-
Perm元空间
存储的是java运行时的一些环境或类信息,这个区域不存在垃圾回收。关闭虚拟机就会释放这个区域的内存,这个区域常驻内存,用来存放JDK自身携带的Class对象、Interface元数据。jdk1.8之前被称为永久代。
注意:元空间在逻辑上存在,在物理上不存在。新生代+老年代的内存空间=JVM分配的总内存。
什么是OOM
内存溢出,产生原因:
- 分配的太少
- 用的太多
- 用完没释放
GC垃圾回收
主要在年轻代和老年代。
首先对象出生在伊甸园区,假设伊甸园区只能存在一定数量的对象,则每当存满时就会出发一次轻GC(Minor GC)。轻GC清理后,有的对象可能还存在引用,就活下来了,活下来的对象就进入幸存区;有的对象没用了,就被GC清理掉了;每次轻GC都会使得伊甸园区为空。
如果幸存区和伊甸园区都满了,则会进入老年代,如果老年代满了,就会出发一次重GC(FullGC),年轻代+老年代的对象都会清理一次,活下来的对象都进入老年代。
如果新生代和老年代都满了,则OOM。
- Minor GC:伊甸园区满时触发,从年轻代回收内存
- Full GC:老年代满时触发,清理整个堆空间
- Major GC:清理老年代
什么情况下永久区会崩?一个启动类加载了大量的第三方jar包,Tomcat部署了过多应用,或者大量动态生成的反射类,这些东西不断的被加载,知道内存满,就会出现OOM。
堆内存调优
查看并设置JVM堆内存
public class Test{
public static void main(String[] args){
//返回jvm试图使用的最大内存
long max = Runtime.getRuntime().maxMemory();
//返回jvm的初始化内存
long total = Runtime.getRuntime().totalMemory();
//默认情况下:分配的总内存为电脑内存的1/4,初始化内存为电脑内存的1/64
System.out.println("max=" + max / (double) 1024 / 1024 / 1024 + "G");
System.out.println("total=" + total / (double) 1024 / 1024 / 1024 + "G");
}
}
我们可以手动调整堆内存的大小,在VM options 中可以指定jvm试图使用的最大内存和jvm初始化内存的大小。
-Xms1024m -Xmx1024m -Xlog:gc*
- -Xms用来设置jvm试图使用的最大内存
- -Xmx用来设置jvm初始化内存
- -Xlog:gc*用来打印GC垃圾回收信息
怎么排除OOM错误?
-
尝试扩大堆内存看结果
-
利用内存快照工具JProfiler
作用:分析Dump内存文件,快速定位内存泄漏;获得堆中的文件;获得大的对象
Dump文件是进程的内存镜像,可以把程序的执行状态通过调试器保存到dump文件中
import java.util.ArrayList; public class Test{ byte[] array = new byte[1024*1024];//1M public static void main(String[] args){ ArrayList<Test> list = new ArrayList<>(); int count = 0; try{ while(true){ list.add(new Test()); count++; } }catch(Exception e){ System.out.println("count="+count); e.printStackTrace(); } } }
运行程序,报错OOM。
接下来设置一下堆内存并附加生成dump文件的指令
-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
-XX:+HeapDumpOnOutOfMemoryError表示当JVM发生OOM时,自动生成DUMP文件。再次点击运行,下载了对应的Dump文件。
分析步骤:
- 右键该类,点击Show in Explorer
- 一直点击上级目录,直到找到.hprof文件
每次打开dump文件查看完后,建议删除,打开文件后生成了很多内容,占内存。
GC垃圾回收
之前已经堆GC垃圾回收流程进行了大概的讲解:JVM在进行GC时,大部分回收都是在年轻代。
GC算法
-
引用计数法(很少使用)
- 每个对象在创建的时候,就给这个对象绑定一个计数器。
- 每当有一个引用指向该对象时,计数器加一;每当有一个指向它的引用被删除时,计数器减一;
- 这样,当没有引用指向该对象时,该对象死亡,计数器为0,这时就应该对这个对象进行垃圾回收操作。
-
复制算法
复制算法主要发生在年轻代(幸存0区和幸存1区)
- 当Eden区满的时候,会触发
轻GC
,每触发一次,活的对象就被转移到幸存区,死的对象就被GC清理掉,所以每次触发轻GC时,Eden区就会清空 - 对象被转移到了幸存区,幸存区又分为
From Space
和To Space
,这两块区域是动态交换的,谁是空的谁就是To Space,然后From Space
就会把全部对象转移到To Space
去; - 那如果两块区域都不为空呢?这就用到了
复制算法
,其中一个区域会将存活的对象转移到另一个区域去,然后将自己区域的内存空间清空,这样该区域为空,又成为了To Space
- 所以每次触发
轻GC
后,Eden区清空,同时To区也清空了,所有的对象都在From区
好处:没有内存碎片
坏处:浪费内存空间(浪费幸存区一半的空间);对象存活率较高的场景下,需要复制的东西太多,效率会下降。
最佳使用环境:对象存活率较低的时候,也就是年轻代。
- 当Eden区满的时候,会触发
-
标记-清除算法
为每个对象存储一个标记位,记录对象的生存状态。
- 标记阶段:这个阶段内,为每个对象更新标记位,检查对象是否死亡。
- 清除阶段:该阶段对死亡的对象进行清除,执行GC操作。
缺点:两次扫描严重浪费时间;会产生内存碎片
优点:不需要额外的空间
-
标记-整理算法
这个是标记-清除算法的一个改进版,又叫做标记-清除-压缩算法。不同的是在第二个阶段,该算法并没有直接对死亡的对象进行清理,而是将所有存货的对象整理一下,放到另一处空间,然后把剩下的所有对象全部清除。可以进一步优化,在内存碎片不太多的情况下,就继续标记清除,到达一定量的时候再压缩。
有没有最优的算法?
没有最优算法,只有最合适的。
GC也称为分代收集算法,对于年轻代,对象存活率低用复制算法;对于老年代,区域大,对象存活率高,用标记清除+标记压缩混合实现。