说起Java,人们首先想到的是Java编程语言,然而事实上,Java是一种技术,它由四方面组成:Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。它们的关系如下图所示:
Java代码编译和执行的过程,正如图所描述,开发人员编写Java代码(.java文件),由Java源码编译器编译成字节码(.class文件),字节码通过类装载器被装入内存,一旦字节码进入虚拟机,它就会被解释器解释执行,或者是被即时代码编译器有选择的转换成机器码执行。
Java平台由Java虚拟机和Java应用程序接口搭建,Java语言则是进入这个平台的通道,用Java语言编写并编译的程序可以运行在这个平台上。
在Java平台的结构中, 可以看出,Java虚拟机(JVM) 处在核心的位置,是链接程序与底层操作系统和硬件的桥梁。它的下方是移植接口,移植接口由两部分组成:适配器和Java操作系统, 其中依赖于平台的部分称为适配器;JVM 通过移植接口在具体的平台和操作系统上实现;在JVM 的上方是Java的基本类库和扩展类库以及它们的API, 利用Java API编写的应用程序(application) 和小程序(Java applet) 可以在任何Java平台上运行而无需考虑底层平台, 就是因为有Java虚拟机(JVM)实现了程序与操作系统的分离,从而实现了Java 的平台无关性。
根据《java虚拟机规范》规定,JVM的基本结构一般如下图所示:
由上图可知JVM基本机构包括:类装载器、内存区域、执行引擎、本地库接口 。
一、类装载器(装载具有适合名称的类或接口)
JVM的类加载是通过ClassLoader及其子类来完成的。
什么是 ClassLoader ?
大家都知道,当我们写好一个 Java 程序之后,不是管是 C/S 还是 B/S 应用,都是由若干个 .class 文件组织而成的一个完整的 Java 应用程序,当程序在运行时,即会调用该程序的一个入口函数来调用系统的相关功能,而这些功能都被封装在不同的 class 文件当中,所以经常要从这个 class 文件中要调用另外一个 class 文件中的方法,如果另外一个文件不存在的,则会引发系统异常。而程序在启动的时候,并不会一次性加载程序所要用的所有class文件,而是根据程序的需要,通过Java的类加载机制(ClassLoader)来动态加载某个 class 文件到内存当中的,从而只有 class 文件被载入到了内存之后,才能被其它 class 所引用。所以 ClassLoader 就是用来动态加载 class 文件到内存当中用的。
ClassLoader 作用:
-
负责将 Class 加载到 JVM 中
-
审查每个类由谁加载(父优先的等级加载机制)
-
将 Class 字节码重新解析成 JVM 统一要求的对象格式
1、ClassLoader 类结构分析
为了更好的理解类的加载机制,我们来深入研究一下 ClassLoader
和他的方法。
public abstract class ClassLoader
ClassLoader类是一个抽象类,
以下是 ClassLoader 常用到的几个方法及其重载方法:
-
ClassLoader
-
defineClass(byte[], int, int) 把字节数组 b中的内容转换成 Java 类,返回的结果是java.lang.Class类的实
例。这个方法被声明为final的 -
findClass(String name) 查找名称为 name的类,返回的结果是java.lang.Class类的实例
-
loadClass(String name) 加载名称为 name的类,返回的结果是java.lang.Class类的实例
-
resolveClass(Class<?>) 链接指定的 Java 类
其中 defineClass 方法用来将 byte 字节流解析成 JVM 能够识别的 Class 对象,有了这个方法意味着我们不仅仅可以通过 class 文件实例化对象,还可以通过其他方式实例化对象,如果我们通过网络接收到一个类的字节码,拿到这个字节码流直接创建类的 Class 对象形式实例化对象。如果直接调用这个方法生成类的 Class 对象,这个类的 Class 对象还没有 resolve ,这个 resolve 将会在这个对象真正实例化时才进行。
2、ClassLoader 的等级加载机制
Java默认提供的三个ClassLoader
BootStrap ClassLoader:称为启动类加载器,是Java类加载层次中最顶层的类加载器,负责加载JDK中的核心类库,如:rt.jar、resources.jar、charsets.jar等,可通过如下程序获得该类加载器从哪些地方加载了相关的jar或class文件:
public class BootStrapTest
{
public static void main(String[] args)
{
java.net.URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
for (int i = 0; i < urls.length; i++) {
System.out.println(urls[i].toExternalForm());
}
}
}
以下内容是上述程序从本机JDK环境所获得的结果:
其实上述结果也是通过查找 sun.boot.class.path 这个系统属性所得知的。
System.out.println(System.getProperty("sun.boot.class.path"));
打印结果:C:\Java\jdk1.8.0_60\jre\lib\resources.jar;C:\Java\jdk1.8.0_60\jre\lib\rt.jar;C:\Java\jdk1.8.0_60\jre\lib\sunrsasign.jar;C:\Java\jdk1.8.0_60\jre\lib\jsse.jar;C:\Java\jdk1.8.0_60\jre\lib\jce.jar;C:\Java\jdk1.8.0_60\jre\lib\charsets.jar;C:\Java\jdk1.8.0_60\jre\lib\jfr.jar;C:\Java\jdk1.8.0_60\jre\classes
Extension ClassLoader:称为扩展类加载器,负责加载Java的扩展类库,Java 虚拟机的实现会提供一个扩展库目录。该类加载器在此目录里面查找并加载 Java 类。默认加载JAVA_HOME/jre/lib/ext/
目下的所有jar。
System.out.println(System.getProperty("java.ext.dirs"));
输出结果:
C:\Program Files\Java\jdk1.8.0_65\jre\lib\ext
App ClassLoader:称为系统类加载器,负责加载应用程序classpath目录下的所有jar和class文件。一般来说,Java 应用的类都是由它来完成加载的。可以通过 ClassLoader.getSystemClassLoader()
来获取它。
除了系统提供的类加载器以外,开发人员可以通过继承java.lang.ClassLoader
类的方式实现自己的类加载器,以满足一些特殊的需求。
除了引导类加载器之外,所有的类加载器都有一个父类加载器。 给出的 getParent()方法可以得到。对于
系统提供的类加载器来说,系统类加载器的父类加载器是扩展类加载器,而扩展类加载器的父类加载器是引导类加载器;对于开发人员编写的类加载器来说,其父类加载器是加载此类加载器 Java 类的类加载器。因为类加载器 Java 类如同其它的 Java 类一样,也是要由类加载器来加载的。一般来说,开发人员编写的类加载器的父类加载器是系统类加载器。类加载器通过这种方式组织起来,形成树状结构。树的根节点就是引导类加载器。
ClassLoader加载类的原理
1. 原理介绍
ClassLoader
使用的是双亲委托模型来搜索类的,每个ClassLoader
实例都有一个父类加载器的引用(不是继承的关系,是一个包含的关系),虚拟机内置的类加载器(Bootstrap ClassLoader
)本身没有父类加载器,但可以用作其它ClassLoader实例的的父类加载器。当一个ClassLoader
实例需要加载某个类时,它会试图亲自搜索某个类之前,先把这个任务委托给它的父类加载器,这个过程是由上至下依次检查的,首先由最顶层的类加载器Bootstrap ClassLoader
试图加载,如果没加载到,则把任务转交给Extension ClassLoader
试图加载,如果也没加载到,则转交给App ClassLoader
进行加载,如果它也没有加载得到的话,则返回给委托的发起者,由它到指定的文件系统或网络等URL中加载该类。如果它们都没有加载到这个类时,则抛出ClassNotFoundException
异常。否则将这个找到的类生成一个类的定义,并将它加载到内存当中,最后返回这个类在内存中的Class实例对象。
2、为什么要使用双亲委托这种模型呢?
因为这样可以避免重复加载,当父亲已经加载了该类的时候,就没有必要 ClassLoader
再加载一次。考虑到安全因素,我们试想一下,如果不使用这种委托模式,那我们就可以随时使用自定义的String来动态替代java核心api中定义的类型,这样会存在非常大的安全隐患,而双亲委托的方式,就可以避免这种情况,因为String已经在启动时就被引导类加载器(Bootstrcp ClassLoader
)加载,所以用户自定义的ClassLoader
永远也无法加载一个自己写的String,除非你改变JDK中ClassLoader
搜索类的默认算法。
类与类加载器
类加载器虽然只用于实现类的加载动作,但它在Java程序中起到的作用却远远不限于类加载阶段。对于任意一个类,都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性,每一个类加载器,都拥有一个独立的类名称空间。这句话可以表达更通俗一些:比较两个类是否”相等”,只有再这两个类是有同一个类加载器加载的前提下才有意义,否则,即使这两个类来源于同一个Class 文件,被同一个虚拟机加载,只要加载它们的类加载器不同,那这两个类就必定不相等。
类加载器源码分析
Launcher
public Launcher() {
ExtClassLoader localExtClassLoader;
try {
// 扩展类加载器
localExtClassLoader = ExtClassLoader.getExtClassLoader();
} catch (IOException localIOException1) {
throw new InternalError("Could not create extension class loader", localIOException1);
}
try {
// 应用类加载器
this.loader = AppClassLoader.getAppClassLoader(localExtClassLoader);
} catch (IOException localIOException2) {
throw new InternalError("Could not create application class loader", localIOException2);
}
// 设置AppClassLoader为线程上下文类加载器
Thread.currentThread().setContextClassLoader(this.loader);
// ...
static class ExtClassLoader extends java.net.URLClassLoader
static class AppClassLoader extends java.net.URLClassLoader
}
Launcher初始化了ExtClassLoader和AppClassLoader,并将AppClassLoader设置为线程上下文类加载器。
ExtClassLoader和AppClassLoader都继承自URLClassLoader,而最终的父类则为ClassLoader
初始化AppClassLoader时传入了ExtClassLoader实例,当我们进入源码跟踪,会来到URLClassLoader 中
public URLClassLoader(URL[] urls, ClassLoader parent,
URLStreamHandlerFactory factory) {
super(parent);
// this is to make the stack depth consistent with 1.1
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkCreateClassLoader();
}
ucp = new URLClassPath(urls, factory);
acc = AccessController.getContext();
}
可以得知,这个ExtClassLoader 作为了AppClassLoader 的parent,在前面ClassLoader 源码中,我们知道有个parent 字段,这里就是在初始化这个字段。
双亲委派
要理解双亲委派,可以查看ClassLoader.loadClass方法:
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// 检查是否已经加载过
Class<?> c = findLoadedClass(name);
if (c == null) { // 没有被加载过
long t0 = System.nanoTime();
// 先委派给父类加载器加载
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
//如果父加载器不存在,则委托给启动类加载器 加载
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// 如果父类加载器无法加载,自身才尝试加载
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
先检查是否已经被加载过,若没有加载则调用父加载器的loadClass() 方法,若父加载器为空,则默认使用启动类加载器作为父加载器。如果父加载器失败,再调用自己的findClass 方法进行加载
3、 但是JVM在搜索类的时候,又是如何判定两个class是相同的呢?
JVM在判定两个class是否相同时,不仅要判断两个类名是否相同,而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下,JVM才认为这两个class是相同的。就算两个class是同一份class字节码,如果被两个不同的ClassLoader实例所加载,JVM也会认为它们是两个不同class。比如网络上的一个Java类org.classloader.simple.NetClassLoaderSimple
,javac编译之后生成字节码文件NetClassLoaderSimple.class
,ClassLoaderA
和ClassLoaderB
这两个类加载器并读取了NetClassLoaderSimple.class
文件,并分别定义出了java.lang.Class
实例来表示这个类,对于JVM来说,它们是两个不同的实例对象,但它们确实是同一份字节码文件,如果试图将这个Class实例生成具体的对象进行转换时,就会抛运行时异常java.lang.ClassCaseException
,提示这是两个不同的类型。现在通过实例来验证上述所描述的是否正确:
1)、在web服务器上建一个org.classloader.simple.NetClassLoaderSimple.java
类
public class NetClassLoaderSimple
{
private NetClassLoaderSimple instance;
public void setNetClassLoaderSimple(Object object){
this.instance = (NetClassLoaderSimple)object;
}
}
org.classloader.simple.NetClassLoaderSimple
类的setNetClassLoaderSimple
方法接收一个Object类型参数,并将它强制转换成org.classloader.simple.NetClassLoaderSimple
类型。
2)、测试两个class是否相同 NetWorkClassLoader.java
package classloader;
public class NewworkClassLoaderTest {
public static void main(String[] args) {
try {
//测试加载网络中的class文件
String rootUrl = "http://localhost:8080/httpweb/classes";
String className = "org.classloader.simple.NetClassLoaderSimple";
NetworkClassLoader ncl1 = new NetworkClassLoader(rootUrl);
NetworkClassLoader ncl2 = new NetworkClassLoader(rootUrl);
Class<?> clazz1 = ncl1.loadClass(className);
Class<?> clazz2 = ncl2.loadClass(className);
Object obj1 = clazz1.newInstance();
Object obj2 = clazz2.newInstance();
clazz1.getMethod("setNetClassLoaderSimple", Object.class).invoke(obj1, obj2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
首先获得网络上一个class文件的二进制名称,然后通过自定义的类加载器NetworkClassLoader创建两个实例,并根据网络地址分别加载这份class,并得到这两个ClassLoader实例加载后生成的Class实例clazz1和clazz2,最后将这两个Class实例分别生成具体的实例对象obj1和obj2,再通过反射调用clazz1中的setNetClassLoaderSimple方法。
3)、查看测试结果
结论:从结果中可以看出,运行时抛出了java.lang.ClassCastException
异常。虽然两个对象obj1和 obj2的类的名字相同,但是这两个类是由不同的类加载器实例来加载的,所以JVM认为它们就是两个不同的类。
了解了这一点之后,就可以理解代理模式的设计动机了。代理模式是为了保证 Java 核心库的类型安全。所有 Java 应用都至少需要引用 java.lang.Object类,也就是说在运行的时候,java.lang.Object这个类需要被加载到 Java 虚拟机中。如果这个加载过程由 Java 应用自己的类加载器来完成的话,很可能就存在多个版本的 java.lang.Object类,而且这些类之间是不兼容的。通过代理模式,对于 Java 核心库的类的加载工作由引导类加载器来统一完成,保证了Java 应用所使用的都是同一个版本的 Java 核心库的类,是互相兼容的。
不同的类加载器为相同名称的类创建了额外的名称空间。相同名称的类可以并存在 Java 虚拟机中,只需要用不同的类加载器来加载它们即可。不同类加载器加载的类之间是不兼容的,这就相当于在 Java 虚拟机内部创建了一个个相互隔离的 Java 类空间。
ClassLoader的体系架构:
类加载器的树状组织结构
测试一:
public class ClassLoaderTree
{
public static void main(String[] args) {
ClassLoader loader = ClassLoaderTree.class.getClassLoader();
while (loader!=null){
System.out.println(loader.toString());
loader = loader.getParent();
}
System.out.println(loader);
}
}
每个 Java 类都维护着一个指向定义它的类加载器的引用,通过 getClassLoader()方法就可以获取到此引用。代码中通过递归调用 getParent()方法来输出全部的父类加载器。
结果是:
测试二:
将ClassLoaderTree.class打包成ClassLoaderTree.jar,放到Extension ClassLoader的加载目录下(JAVA_HOME/jre/lib/ext),然后重新运行这个程序,得到的结果会是什么样呢?
打印结果是:
打印结果分析:
为什么第一行的结果是ExtClassLoader呢?
因为 ClassLoader 的委托模型机制,当我们要用 ClassLoaderTest.class 这个类的时候,AppClassLoader 在试图加载之前,先委托给 Bootstrcp ClassLoader,Bootstracp ClassLoader 发现自己没找到,它就告诉 ExtClassLoader,兄弟,我这里没有这个类,你去加载看看,然后 Extension ClassLoader 拿着这个类去它指定的类路径(JAVA_HOME/jre/lib/ext)试图加载,唉,它发现在ClassLoaderTest.jar 这样一个文件中包含 ClassLoaderTest.class 这样的一个文件,然后它把找到的这个类加载到内存当中,并生成这个类的 Class 实例对象,最后把这个实例返回。所以 ClassLoaderTest.class 的类加载器是 ExtClassLoader。
第二行的结果为null,是因为ExtClassLoader的父类加载器是Bootstrap ClassLoader。
JVM加载class文件的两种方法;
-
隐式加载, 程序在运行过程中当碰到通过new 等方式生成对象时,隐式调用类装载器加载对应的类到jvm中。
-
显式加载, 通过class.forname()、this.getClass.getClassLoader().loadClass()等方法显式加载需要的类,或者我们自己实现的 ClassLoader 的 findlass() 方法。
下面介绍下 class.forName的加载类方法:
Class.forName
是一个静态方法,同样可以用来加载类。该方法有两种形式:Class.forName(String name,boolean initialize, ClassLoader loader)和Class.forName(String className)
。第一种形式的参数name
表示的是类的全名;initialize
表示是否初始化类;loader
表示加载时使用的类加载器。第二种形式则相当于设置了参数 initialize的值为 true,loader的值为当前类的类加载器。Class.forName
的一个很常见的用法是在加载数据库驱动的时候。如Class.forName("org.apache.derby.jdbc.EmbeddedDriver")
用来加载 Apache Derby 数据库的驱动。
类加载的动态性体现:
一个应用程序总是由n多个类组成,Java程序启动时,并不是一次把所有的类全部加载后再运行,它总是先把保证程序运行的基础类一次性加载到jvm中,其它类等到jvm用到的时候再加载,这样的好处是节省了内存的开销,因为java最早就是为嵌入式系统而设计的,内存宝贵,这是一种可以理解的机制,而用到时再加载这也是java动态性的一种体现。
3、如何加载 class 文件
-
第一阶段找到 .class 文件并把这个文件包含的字节码加载到内存中。
-
第二阶段中分三步,字节码验证;class 类数据结构分析及相应的内存分配;最后的符号表的链接。
-
第三阶段是类中静态属性和初始化赋值,以及静态块的执行等。
3.1 、加载字节码到内存
其实在抽象类classloader中并没有定义如何去加载
- 如何去找到指定类并且把它的字节码加载内存需要的子类中去实现,也就是要实现findclass方法。
- 我们来看一下子类urlclassloader是如何实现findclass的,在urlclassloader中通过一个urlclasspath帮助取的要加载的class文件字节流,而这个urlclasspath定义了到哪里去找这个class文件。
- 如果找到了这个class文件,再读取它的byte字节流,通过defineclass方法来创建类对象。
实际上,ext把默认的搜索路径指定为环境变量配置的lib/ext了。而appclassloader则指向classpath的环境变量。
3.2 、验证与分析
-
字节码验证,类装入器对于类的字节码要做很多检测,以确保格式正确,行为正确。
-
类装备,准备代表每个类中定义的字段、方法和实现接口所必须的数据结构。
-
解析,装入器装入类所引用的其他所有类。
4、常见加载类错误分析
4.1 、 ClassNotFoundExecption
ClassNotFoundExecption 异常是平常碰到的最多的。这个异常通常发生在显示加载类的时候。
public class ClassNotFoundExceptionTest
{
public static void main(String[] args) {
try {
Class.forName("NotFoundClass");
}catch (ClassNotFoundException e){
e.printStackTrace();
}
}
}
显示加载一个类通常有:
-
通过类 Class 中的 forName() 方法
-
通过类 ClassLoader 中的 loadClass() 方法
-
通过类 ClassLoader 中的 findSystemClass() 方法
出现这种错误其实就是当 JVM 要加载指定文件的字节码到内存时,并没有找到这个文件对应的字节码,也就是这个文件并不存在。解决方法就是检查在当前的 classpath 目录下有没有指定的文件。
4.2 、 NoClassDefFoundError
在JavaDoc中对NoClassDefFoundError的产生可能的情况就是使用new关键字、属性引用某个类、继承了某个接口或者类,以及方法的某个参数中引用了某个类,这时就会触发JVM或者类加载器实例尝试加载类型的定义,但是该定义却没有找到,影响了执行路径。换句话说,在编译时这个类是能够被找到的,但是在执行时却没有找到。
解决这个错误的方法就是确保每个类引用的类都在当前的classpath下面。
4.3 、 UnsatisfiedLinkError
该错误通常是在 JVM 启动的时候,如果 JVM 中的某个 lib 删除了,就有可能报这个错误。
public class UnsatisfiedLinkErrorTest
{
public native void nativeMethod();
static {
System.loadLibrary("NoLib");
}
public static void main(String[] args) {
new UnsatisfiedLinkErrorTest().nativeMethod(); //解析native标识的方法时JVM找不到对应的库文件
}
}
4.4 、 ClassCastException
该错误通常出现强制类型转换时出现这个错误。
public class ClassCastExceptionTest
{
public static Map m = new HashMap(){
{
put("a", "2");
}
};
public static void main(String[] args) {
Integer integer = (Integer) m.get("a"); //将m强制转换成Integer类型
System.out.println(integer);
}
}
注意:JVM 在做类型转换时的规则:
-
对于普通对象,对象必须是目标类的实例或目标类的子类的实例。如果目标类是接口,那么会把它当作实现了该接口的一个子类。
-
对于数组类型,目标类必须是数组类型或 java.lang.Object、java.lang.Cloneable、java.io.Serializable。
如果不满足上面的规则,JVM 就会报错,有两种方式可避免错误:
-
在容器类型中显式的指明这个容器所包含的对象类型。
-
先通过 instanceof 检查是不是目标类型,然后再进行强制类型的转换。
如果不满足上面的规则,JVM 就会报错,有两种方式可避免错误:
-
在容器类型中显式的指明这个容器所包含的对象类型。
-
先通过 instanceof 检查是不是目标类型,然后再进行强制类型的转换。
5、常用的 ClassLoader 分析
web应用中的一个servlet是如何加载类的,我们看一下它的classloader,发现层级关系是extclassloader -> appclassloader -> standardclassloader -> webappclassloader
tomcat在何时创建这些classloader:
- standardclassloader在bootstrap类(tomcat的一个类)的initclassloaders方法中创建的。
- standardclassloader创建成功时,会被设置为整个tomcat的根classloader
- tomcat使用standardclassloader加载catalina并创建对象(catalina是tomcat的默认容器,catilina是tomcat以前的名字),整个tomcat容器的类加载器也是standardclassloader。
- standardclassloader实际上并不处理加载逻辑,因为它是appclassloader的代理,实际上的加载器还是appclassloader。
- tomcat容器本身(catilina)是谁加载的不重要,我们要了解其中的servlet是谁加载的。
- web.xml配置了每个servlet对应的类,所以应该是由类加载器显示加载的。(解析xml显示加载)
- standardcontext(解析web.xml后映射的上下文实例)检查classloader是否存在,然后instancemanager这个类会去真正加载这些servlet实例。
- instancemanager类使用的classloader是webappclassloader,它的处理和appclassloader有所不同。
1 首先检查webappclassloader是否已加载
2 如果没有,则检查在jvm中是否已加载,调用classloader的findloadedclass
3 如果前两个缓存没有,则用appclassloader加载
4 检查类是否在特殊的包名下,如果在的话可以用standardclassloader来加载
5 如果还没找到,则由webappclassloader来加载,回去web-inf/classes目录下查找,然后用defineclass方法生成Class对象。
6、如何实现自己的 ClassLoader
ClassLoader 能够完成的事情有以下情况:
-
在自定义路径下查找自定义的class类文件。
-
对我们自己要加载的类做特殊处理。
-
可以定义类的实现机制。
虽然在绝大多数情况下,系统默认提供的类加载器实现已经可以满足需求。但是在某些情况下,您还是需要为应用开发出自己的类加载器。比如您的应用通过网络来传输 Java 类的字节代码,为了保证安全性,这些字节代码经过了加密处理。这个时候您就需要自己的类加载器来从某个网络地址上读取加密后的字节代码,接着进行解密和验证,最后定义出要在 Java 虚拟机中运行的类来。
定义自已的类加载器分为两步:
1、继承java.lang.ClassLoader
2、重写父类的findClass方法
6.1 、文件系统类加载器
加载存储在文件系统上的 Java 字节代码。
public class FileSystemClassLoader extends ClassLoader
{
private String rootDir;
public FileSystemClassLoader(String rootDir){
this.rootDir = rootDir;
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] classData = getClassData(name);
if (classData == null){
throw new ClassNotFoundException();
}
else {
return defineClass(name, classData, 0, classData.length);
}
}
private byte[] getClassData(String className) {
String path = classNameToPath(className);
try {
InputStream ins = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int bufferSize = 4096;
byte[] buffer = new byte[bufferSize];
int bytesNumRead = 0;
while ((bytesNumRead = ins.read(buffer)) != -1){
baos.write(buffer, 0, bytesNumRead);
}
return baos.toByteArray();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private String classNameToPath(String className) {
return rootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
}
}
类 FileSystemClassLoader继承自类java.lang.ClassLoader。java.lang.ClassLoader类的方法loadClass()封装了前面提到的代理模式的实现。该方法会首先调用 findLoadedClass()方法来检查该类是否已经被加载过;如果没有加载过的话,会调用父类加载器的loadClass()方法来尝试加载该类;如果父类加载器无法加载该类的话,就调用 findClass()方法来查找该类。因此,为了保证类加载器都正确实现代理模式,在开发自己的类加载器时,最好不要覆写 loadClass()方法,而是覆写findClass()方法。
类 FileSystemClassLoader的 findClass()方法首先根据类的全名在硬盘上查找类的字节代码文件(.class 文
件),然后读取该文件内容,最后通过 defineClass()方法来把这些字节代码转换成 java.lang.Class类的实例。
6.2 、 网络类加载器
一个网络类加载器来说明如何通过类加载器来实现组件的动态更新。即基本的场景是:Java 字节代码(.class)文件存放在服务器上,客户端通过网络的方式获取字节代码并执行。当有版本更新的时候,只需要替换掉服务
器上保存的文件即可。通过类加载器可以比较简单的实现这种需求。
类 NetworkClassLoader 负责通过网络下载 Java 类字节代码并定义出 Java 类。它的实现与FileSystemClassLoader 类似。在通过 NetworkClassLoader 加载了某个版本的类之后,一般有两种做法来使用它。第一种做法是使用 Java 反射 API。另外一种做法是使用接口。需要注意的是,并不能直接在客户端代码中引用从服务器上下载的类,因为客户端代码的类加载器找不到这些类。使用 Java 反射 API 可以直接调用 Java 类的
方法。而使用接口的做法则是把接口的类放在客户端中,从服务器上加载实现此接口的不同版本的类。在客户端通过相同的接口来使用这些实现类。
7、类加载器与Web容器
对于运行在 Java EE™容器中的 Web 应用来说,类加载器的实现方式与一般的 Java 应用有所不同。不同的 Web 容器的实现方式也会有所不同。以 Apache Tomcat 来说,每个Web 应用都有一个对应的类加载器实例。该类加载器也使用代理模式,所不同的是它是首先尝试去加载某个类,如果找不到再代理给父类加载器。这与一般类加载器的顺序是相反的。这是 Java Servlet 规范中的推荐做法,其目的是使得Web 应用自己的类的优先级高于 Web 容器提供的类。这种代理模式的一个例外是:Java 核心库的类是不在查找范围之内的。这也是为了保证 Java 核心库的类型安全。
绝大多数情况下,Web 应用的开发人员不需要考虑与类加载器相关的细节。下面给出几条简单的原则:
-
每个 Web 应用自己的 Java 类文件和使用的库的 jar 包,分别放在 WEB-INF/classes和 WEB-INF/lib目录下面。
-
多个应用共享的 Java 类文件和 jar 包,分别放在 Web 容器指定的由所有 Web 应用共享的目录下面。
-
当出现找不到类的错误时,检查当前类的类加载器和当前线程的上下文类加载器是否正确
二、Java 内存模型
2.1.定义
程序计数器
- 程序计数器(Program Counter Register)是一块较小的内存空间,他可以看作是当前线程所执行的字节码的行号指示器。
- 在虚拟机的概念模型里(仅是概念模型,各种虚拟机可能会通过一些更高效的方式去实现),字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令,分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。
- 程序计数器是线程私有的,每条线程都有一个独立的独立的程序计数器,各条线程之间计数器互不影响。
- 如果线程正在执行的是一个Java方法,这个计数器记录的是正在执行的虚拟机字节码指令的地址;如果正在执行的Native方法,这个计数器值则为空(Undefined)。此内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。
Java虚拟机栈
- Java虚拟机栈是线程私有的,他的生命周期与线程相同。
- 虚拟机栈描述的是Java方法执行的内存模型:每个方法在执行的同时都会创建一个栈帧(Stack Frame),用于包含局部变量表、操作数栈、动态链接、方法出口等信息。每个方法从调用到执行完成这个过程,就对应这一个栈帧在虚拟机栈中的入栈到出栈的过程。
- 局部变量表存放了编译期可知的各种基本数据类型和对象引用(
reference
类型,他不等同于对象本身,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄或其他与此相关的位置)和returnAddress
类型(指向了一条字节码指令的地址) 。 - 其中64位长度的long和double类型会占用2个局部变量空间,其余的数据类型只会占用1个局部变量空间。局部变量表所需的内存空间在编译期间完成内存分配。当进入一个方法时,这个方法需要在帧中分配多大的内存空间是完全确定的,在方法运行期间不会改变局部变量表的大小。
- 在Java虚拟机规范中,对这个区域规定了两种异常状态:如果线程请求的栈的深度大于虚拟机允许的深度,将抛出
StackOverFlowError
异常(栈溢出);如果虚拟机栈可以动态扩展(现在大部分Java虚拟机都可以动态扩展,只不过Java虚拟机规范中也允许固定长度的java虚拟机栈),如果扩展时无法申请到足够的内存空间,就会抛出OutOfMemoryError
异常(没有足够的内存)。
本地方法栈
- 本地方法栈(Native Method Stacks)与虚拟机栈所发挥的作用是非常相似的,他们之间的区别不过是虚拟机栈为虚拟机执行Java方法(也就是字节码)服务,而本地方法栈则为虚拟机使用到的本地Native方法服务。
- 在虚拟机规范中对本地方法栈中的使用方法、语言、数据结构并没有强制规定,因此具体的虚拟机可以自由实现它。甚至有的虚拟机(例如Sun HotSpot虚拟机)直接就把本地方法栈和虚拟机栈合二为一。
- 本地方法栈也会抛出StackOverFlowError和OutOfmMemoryError异常。
Java堆
- Java堆(Java Heap)是Java虚拟机管理内存中的最大一块。
- Java堆是所有线程共享的一块内存管理区域。
- 此内存区域唯一目的就是存放对象的实例,几乎所有对象实例都在堆中分配内存。这一点在Java虚拟机规范中的描述是:所有对象实例以及数组都要在堆上分配,但是随着JIT编译器的发展与逃逸技术逐渐成熟,栈上分配、标量替换优化技术将会导致一些微妙的变化发生,所有的对象都分配在堆上也不是变的那么“绝对”了。
- Java堆是垃圾回收器管理的主要区域,因此很多时候也被称为GC堆(Garbage Collected Heap)。
- 从内存回收的角度来看,由于现在收集器基本都采用分代收集算法,所以Java堆中还可以细分为:新生代和年老代。再在细致一点的划分可以分为:Eden空间、From Survivor空间、To Survivor空间等。
- 从内存分配的角度来看,线程共享的Java堆中可能划分出多个线程私有的分配缓冲区。
- 不过无论如何划分,都与存放内容无关,无论哪个区域存放的都是对象实例。进一步划分的目的是为了更好的回收内存,或者更快的分配内存。
- Java堆可以处在物理上不连续的内存空间,只要逻辑上是连续的即可。在实现上既可以实现成固定大小,也可以是可扩展的大小,不过当前主流的虚拟机都是按照可扩展来实现的(通过-Xmx和-Xms控制)。
- 如果在堆中没有内存实例完成分配,并且堆也无法在扩展时将会抛出OutOfMemoryError异常。
方法区
- 方法区是各个线程共享的内存区域
- 方法区用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
- 虽然Java虚拟机规范把方法区描述为堆的一部分,但是他还有个别名叫做Non-heap(非堆),目的应该是与Java堆区分开来。
- 根据Java虚拟机规范的规定,当方法区无法满足内存分配需求时,将抛出OutOfMemoryError 异常。
- Java虚拟机规范对方法区的限制非常宽松,除了和Java堆一样不需要连续的内存和可以选择固定大小或者可扩展外,还可以选择不实现垃圾收集。相对而言,垃圾收集在这个区域是比较少出现的,但并非数据进入了方法区就如永久代的名字一样永久存在了。这区域的内存回收目标重要是针对常量池的回收和类型的卸载,一般来说这个内存区域的回收‘成绩’比较难以令人满意。尤其是类型的卸载条件非常苛刻,但是这部分的回收确实是必要的。在Sun公司的bug列表中,曾出现过的若干个严重的bug就是由于低版本的HotSpot虚拟机对此区域未完成回收导致的内存溢出。
注意:方法区与永久代
- 对于习惯在HotSpot虚拟机上开发、部署程序的开发者来说,很多人都更愿意把方法区称为“永久代”(Permanent Generation),本质上两者并不等价。
- 仅仅是因为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区,或者说使用永久代来实现方法区而已,这样HotSpot的垃圾收集器可以像管理Java堆一样管理这部分内存,能够省去专门为方法区编写内存管理代码的工作。
- 对于其他虚拟机(如 BEA JRockit、IBM J9 等)来说是不存在永久代的概念的。
- 对于HotSpot虚拟机,根据官方发布的路线图信息,现在也有放弃永久代并逐步改为采用Native Memory来实现方法区的规划了,在目前已经发布的JDK1.7的HotSpot中,已经把原本放在永久代的字符串常量池移出。
直接内存
- 直接内存(Direct Memory)并不是虚拟机运行时数据区的一部分,也不是 Java 虚拟机规范中定义的内存区域。但是这部分内存也被频繁地使用,而且也可能导致 OutOfMemoryError 异常出现。
- 在 JDK 1.4 中新加入了 NIO(New Input/Output)类,引入了一种基于通道(Channel)与缓冲区(Buffer)的 I/O 方式,它可以使用Native函数库直接分配堆外内存,然后通过一个存储在Java堆中的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样能在一些场景中显著提高性能,因为避免了在 Java 堆和 Native 堆中来回复制数据。
- 显然,本机直接内存的分配不会受到 Java 堆大小的限制。但是,既然是内存,肯定还是会受到本机总内存(包括 RAM 以及 SWAP 区或者分页文件)大小以及处理器寻址空间的限制。服务器管理员在配置虚拟机参数时,会根据实际内存设置
-Xms
等参数信息,但经常忽略直接内存,使得各个内存区域总和大于物理内存限制(包括物理的和操作系统级的限制),从而导致动态扩展时出现 OutOfMemoryError 异常。
常量池
Class常量池
- Class文件中除了有类的版本、字段、方法、接口等描述信息外,还有一项信息是常量池(Constant Pool Table),用于存放编译期生成的各种字面量和符号引用。
- 字面量(Literal):文本字符串(如
String str = "SpiderLucas"
中SpiderLucas
就是字面量)、八种基本类型的值(如int i = 0
中0
就是字面量)、被声明为final
的常量等; - 符号引用(Symbolic References):类和方法的全限定名、字段的名称和描述符、方法的名称和描述符。
- 每个class文件都有一个class常量池。
字符串常量池
- 参考资料来源:Java中的常量池、彻底弄懂字符串常量池等相关问题、Java中String字符串常量池
- 字符串常量池中的字符串只存在一份。
- 字符串常量池(String Constant Pool)是存储Java String的一块内存区域,在JDK 6之前是放置于方法区的,在JDK 7之后放置于堆中。
- 在HotSpot中实现的字符串常量池功能的是一个StringTable类,它是一个Hash表,默认值大小长度是1009;这个StringTable在每个HotSpot VM的实例只有一份,被所有的类共享。字符串常量由一个一个字符组成,放在了StringTable上。
- StringTable的长度:在JDK 6中,StringTable的长度是固定的,因此如果放入String Pool中的String非常多,就会造成hash冲突,导致链表过长,当调用String#intern()时会需要到链表上一个一个找,从而导致性能大幅度下降;在JDK 7中,StringTable的长度可以通过参数指定:
-XX:StringTableSize=1024
。 - 字符串常量池中存放的内容:在JDK 6及之前版本中,String Pool里放的都是字符串常量;JDK 7中,由于String#intern()发生了改变,因此String Pool中也可以存放放于堆内的字符串对象的引用。
intern() 函数
- 在JDK 6中,
intern()
的处理是先判断字符串常量是否在字符串常量池中,如果存在直接返回该常量;如果没有找到,则将该字符串常量加入到字符串常量区,也就是在字符串常量区建立该常量。 - 在JDK 7中,
intern()
的处理是先判断字符串常量是否在字符串常量池中,如果存在直接返回该常量,如果没有找到,说明该字符串常量在堆中,则处理是把堆区该对象的引用加入到字符串常量池中,以后别人拿到的是该字符串常量的引用,实际存在堆中。
字符串常量池案例
String s1 = new String("Spider"); // s1 -> 堆
// 该行代码创建了几个对象
// 两个对象(不考虑对象内部的对象):首先创建了一个字符串常量池的对象,然后创建了堆里的对象
s1.intern(); // 字符串常量池中存在"Spider",直接返回该常量
String s2 = "Spider"; // s2 -> 字符串字符串常量池
System.out.println(s1 == s2); // false
String s3 = new String("Str") + new String("ing"); // s3 -> 堆
// 该行代码创建了几个对象?
// 反编译后的代码:String s3 = (new StringBuilder()).append(new String("Str")).append(new String("ing")).toString();
// 六个对象(不考虑对象内部的对象):两个字符串常量池的对象"Str"和"ing",两个堆的对象"Str"和"ing",一个StringBuilder,一个toString方法创建的new String对象
s3.intern(); // 字符串常量池中没有,在JDK 7中以后会把堆中该对象的引用放在字符串常量池中(JDK 6中创建一个jdk1.6中会在字符串常量池中建立该常量)
String s4 = "String"; // s4 -> 堆(JDK 6:s4 -> 字符串字符串常量池)
System.out.println(s3 == s4); // true(JDK6 false)
String s5 = "AAA";
String s6 = "BBB";
String s7 = "AAABBB"; // s7 -> 字符串常量池
String s8 = s5 + s6; // s8 -> 堆(原因就是如上字符串+的重载)
String s9 = "AAA" + "BBB"; // JVM会对此代码进行优化,直接创建字符串常量池
System.out.println(s7 == s8); // false
System.out.println(s7 == s9); // true(都指向字符串常量池)
方法区与运行时常量池
- 运行时常量池(Runtime Constant Pool)是方法区的一部分。
- Class常量池的内容将在类加载后进入方法区的运行时常量池中存放。
- Java虚拟机对Class文件每一部分(自然也包括常量池)的格式都有严格规定,每一个字节用于存储哪种数据都必须符合规范的要求才会被虚拟机认可、装载和执行,但对于运行时常量池,Java 虚拟机规范没有做任何细节的要求,不同的提供商实现的虚拟机可以按照自己的需要来实现这个内存区域。
- 运行时常量池相对于Class文件常量池的另外一个重要特征是具备动态性,Java 语言并不要求常量一定只有编译期才能产生,也就是并非预置如Class文件中常量池的内容才能进入方法区运行时常量池,运行期间也可能将新的常量放入池中,这种特性被开发人员利用得比较多的便是 String类的intern()方法。
- 既然运行时常量池是方法区的一部分,自然受到方法区内存的限制,当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。
2.3 HotSpot中的对象
2.3.1 对象的创建
new一个对象的全部流程
- 从常量池中查找该类的符号引用,并且检查该符号引用代表的类是否被加载、解析、初始化。如果类已经被加载,则跳转至3;否则跳转至2。
- 执行类的加载过程。
- 为新对象分配内存空间:由于对象所需要内存大小在类加载完成时可以确定,所以可以直接从Java堆中划分一块确定大小的内存。
- 把分配的内存空间都初始化为零值(不包括对象头),如果使用TLAB则该操作可以提前至TLAB中,这是为了保证对象的字段都被初始为默认值。
- 执行init方法,按照程序员的意愿进行初始化。
对象分配内存空间详解
- 指针碰撞:如果堆内存是规整,已经分配和为分配的内存有一个指针作为分界点,那么只需要将指针向空闲内存移动即可。
- 空闲列表:如果内存是不规整的,虚拟机需要维护一个列表,记录那些内存块是可用的。在分配的时候从足够大的空间划分给对象,并更新该列表。
- Java堆是否规整取决于GC是否会压缩整理,Serial、ParNew等带Compact过程的收集器,分配算法是指针碰撞;是用CMS这种基于Mark-Sweep算法的收集器时,分配算法是空闲列表。
分配内存的并发问题
无论是指针碰撞还是空闲列表,都有可能因为并发而产生问题,解决方法有两种:
- 对分配内存空间的动作进行同步处理——实际上JVM采用CAS(Compare And Swap)配上失败重试的方式保证更新操作的原子性。
- 把内存分配的动作按照线程划分在不同的空间,每个线程在Java堆中预先分配一小块内存,成为本地缓冲内存(Tread Local Allocation Buffer,TLAB)。哪个线程需要分配内存,就在哪个线程的TLAB上分配,只有TLAB用完了,才需要同步锁定。可以通过
-XX:+/-UseTLAB
参数来设定。
CAS原理
一个CAS方法包含三个参数CAS(V,E,N)。V表示要更新的变量,E表示预期的值,N表示新值。只有当V的值等于E时,才会将V的值修改为N。如果V的值不等于E,说明已经被其他线程修改了,当前线程可以放弃此操作,也可以再次尝试次操作直至修改成功。基于这样的算法,CAS操作即使没有锁,也可以发现其他线程对当前线程的干扰(临界区值的修改),并进行恰当的处理。
2.3.2 对象的内存布局
在HotSpot虚拟机中,对象在内存中的存储布局可以分为3部分:对象头(Object Header)、实例数据(Instance Data)、对齐填充(Padding)。
对象头第一部分
- 对象头包括两部分信息,第一部分用于存储对象自身的运行时数据, 如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等等,这部分数据的长度在32位和64位的虚拟机(暂不考虑开启压缩指针的场景)中分别为32个和64个Bits,官方称它为“Mark Word”。
- 对象需要存储的运行时数据很多,其实已经超出了32、64位所能记录的限度,但是对象头信息是与对象自身定义的数据无关的额外存储成本,考虑到虚拟机的空间效率,Mark Word被设计成一个非固定的数据结构以便在极小的空间内存储尽量多的信息,原理是它会根据对象的状态复用自己的存储空间。
- 例如在32位的HotSpot虚拟机中对象未被锁定的状态下,Mark Word的32个Bits空间中的25Bits用于存储对象哈希码(HashCode),4Bits用于存储对象分代年龄,2Bits用于存储锁标志位,1Bit固定为0,在其他状态(轻量级锁定、重量级锁定、GC标记、可偏向)下对象的存储内容如下表所示。
对象头第二部分
- 对象头的第二部分是类型指针,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例。
- 并不是所有的虚拟机实现都必须在对象数据上保留类型指针,换句话说,查找对象的元数据信息不一定要经过对象本身。
- 如果对象是一个数组:对象头中还需要一块用于记录数组长度的数据。
实例数据
- 接下来实例数据部分是对象真正存储的有效信息,也既是我们在程序代码里面所定义的各种类型的字段内容。无论是从父类继承下来的,还是在子类中定义的都需要记录下来。
- 这部分的存储顺序会受到虚拟机分配策略参数(FieldsAllocationStyle)和字段在Java源码中定义顺序的影响。HotSpot虚拟机默认的分配策略为longs/doubles、ints、shorts/chars、bytes/booleans、oops(Ordinary Object Pointers),从分配策略中可以看出,相同宽度的字段总是被分配到一起。在满足这个前提条件的情况下,在父类中定义的变量会出现在子类之前。
- 如果 CompactFields参数值为true(默认为true),那子类之中较窄的变量也可能会插入到父类变量的空隙之中。
对齐填充
第三部分对齐填充并不是必然存在的,也没有特别的含义,它仅仅起着占位符的作用。由于HotSpot VM的自动内存管理系统要求对象起始地址必须是8字节的整数倍,换句话说就是对象的大小必须是8字节的整数倍。对象头正好是8字节的倍数(1倍或者2倍),因此当对象实例数据部分没有对齐的话,就需要通过对齐填充来补全。
2.3.3 对象的访问定位
建立对象是为了使用对象,我们的Java程序需要通过栈上的reference数据来操作堆上的具体对象。由于reference类型在Java虚拟机规范里面只规定了是一个指向对象的引用,并没有定义这个引用应该通过什么种方式去定位、访问到堆中的对象的具体位置,对象访问方式也是取决于虚拟机实现而定的。
对象的两种访问定位方式
主流的访问方式有使用句柄和直接指针两种。
- 句柄访问:Java堆中将会划分出一块内存来作为句柄池,reference中存储的就是对象的句柄地址,而句柄中包含了对象实例数据与类型数据的具体各自的地址信息,如下图所示。
- 直接指针:Java堆对象的布局中就必须考虑如何放置访问类型数据的相关信息,reference中存储的直接就是对象地址,如下图所示
两种方式比较
- 句柄访问的优势:reference中存储的是稳定句柄地址,在对象被移动(垃圾收集时移动对象是非常普遍的行为)时只会改变句柄中的实例数据指针,而reference本身不需要被修改。
- 直接指针的优势:最大的好处就是速度更快,它节省了一次指针定位的时间开销,由于对象访问的在Java中非常频繁,因此这类开销积小成多也是一项非常可观的执行成本。
- HotSpot虚拟机:它是使用第二种方式进行对象访问。
- 但在整个软件开发的范围来看,各种语言、框架中使用句柄来访问的情况也十分常见。
2.4 OOM异常分类
2.4.1 堆溢出
Java堆用于存储对象实例,只要不断创建对象,并且保证GC Roots到对象之间有可达路径来避免GC,那么在对象数量到达最大堆容量限制之后便会产生堆溢出。
/**
* VM args: -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError
* 1.将堆的最小值-Xms与最大值-Xmx参数设置为一样可以避免堆自动扩展
* 2.通过参数-XX:+HeapDumpOnOutOfMemoryError可以让虚拟机出现内存异常时Dump当前堆内存堆转储快照
* 3.快照位置默认为user.dir
*/
public class HeapOOM {
static class OOMObject {}
public static void main(String[] args) {
// 保留引用,防止GC
List<OOMObject> list = new ArrayList<>();
for (;;) {
list.add(new OOMObject());
}
}
}
// 运行结果
// java.lang.OutOfMemoryError: Java heap space
// Dumping heap to java_pid72861.hprof ...
// Heap dump file created [27888072 bytes in 0.086 secs]
堆转储快照
以下是JProfiler对转储快照的分析
内存泄漏与内存溢出
- 重点:确认内存中的对象是否是必要的,也就是分清楚到底是出现了内存泄漏(Memory Leak)还是内存溢出(Memory Overflow)
- 内存泄漏:是指程序在申请内存后,无法释放已申请的内存空间,一次内存泄漏似乎不会有大的影响,但内存泄漏堆积后的后果就是内存溢出。
- 内存溢出:是指程序在申请内存时,没有足够的内存空间供其使用。内存泄漏的堆积最终会导致内存溢出。
内存泄漏的分类(按发生方式来分类)
- 常发性内存泄漏:发生内存泄漏的代码会被多次执行到,每次被执行的时候都会导致一块内存泄漏。
- 偶发性内存泄漏:发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境,偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。
- 一次性内存泄漏:发生内存泄漏的代码只会被执行一次,或者由于算法上的缺陷,导致总会有一块仅且一块内存发生泄漏。比如,在类的构造函数中分配内存,在析构函数中却没有释放该内存,所以内存泄漏只会发生一次。
- 隐式内存泄漏:程序在运行过程中不停的分配内存,但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏,因为最终程序释放了所有申请的内存。但是对于一个服务器程序,需要运行几天,几周甚至几个月,不及时释放内存也可能导致最终耗尽系统的所有内存。
处理方式
- 如果是内存泄漏:需要找到泄漏对象的类型信息,和对象与GC Roots的引用链的信息,分析GC无法自动回收它们的原因。
- 如果不存在内存泄漏,即内存中的对象的确必须存活:那就应当检查JVM的参数能否调大;从代码上检查是否某些对象生命周期过长、持有状态时间过长,尝试减少程序运行期的内存消耗。
2.4.2 栈溢出
在HotSpot虚拟机中并不区分虚拟机栈和本地方法栈,对于HotSpot来说,虽然-Xoss参数(设置本地方法栈大小)存在,但实际上是无效的。栈容量只由-Xss参数设定。关于虚拟机栈和本地方法栈,在Java虚拟机规范中描述了两种异常:
- 如果线程请求的栈深度大于虚拟机所允许的最大深度,将抛出StackOverflowError异常。
- 如果虚拟机在扩展栈时无法申请到足够的内存空间,则抛出OutOfMemoryError异常。
这里把异常分成两种情况,看似更加严谨,但却存在着一些互相重叠的地方:当栈空间无法继续分配时,到底是内存太小,还是已使用的栈空间太大,其本质上只是对同一件事情的两种描述而已。
StackOverflowError
/**
* VM args: -Xss256k
* 1. 设置-Xss参数减小栈内存
* 2. 死递归增大此方法栈中本地变量表的长度
*/
public class SOF {
int stackLength = 1;
void stackLeak() {
stackLength++;
stackLeak();
}
public static void main(String[] args) {
SOF sof = new SOF();
try {
sof.stackLeak();
} catch (Throwable e) {
System.out.println("Stack Length:" + sof.stackLength);
throw e;
}
}
}
// Stack Length:2006
// Exception in thread "main" java.lang.StackOverflowError
// at s1.SOF.stackLeak(SOF.java:13)
// at s1.SOF.stackLeak(SOF.java:13)
多线程导致栈OOM异常
/**
* VM Args: -Xss20M
* 通过不断创建线程的方式产生OOM
*/
public class StackOOM {
private void dontStop() {
for (;;) {
}
}
private void stackLeakByThread() {
for (;;) {
Thread thread = new Thread(this::dontStop);
thread.start();
}
}
public static void main(String[] args) {
new StackOOM().stackLeakByThread();
}
}
通过不断创建线程的方式产生OOM异常,但是这样产生的内存溢出异常与栈空间是否足够大并不存在任何联系。或者准确地说,在这种情况下,为每个线程的栈分配的内存越大,反而越容易产生内存溢出异常。
原因:操作系统分配给每个进程的内存是有限制的,假设操作系统的内存为2GB,剩余的内存为2GB(操作系统限制)减去Xmx(最大堆容量),再减去MaxPermSize(最大方法区容量),程序计数器消耗内存很小,可以忽略掉。如果虚拟机进程本身耗费的内存不计算在内,剩下的内存就由虚拟机栈和本地方法栈“瓜分”了。所以每个线程分配到的栈容量越大,可以建立的线程数量自然就越少,建立线程时就越容易把剩下的内存耗尽。
解决方法:如果是建立过多线程导致的内存溢出,在不能减少线程数或者更换64位虚拟机的情况下,就只能通过“减少内存”的手段来解决内存溢出——减少最大堆和减少栈容量来换取更多的线程。
2.4.3 方法区和运行时常量池溢出
由于运行时常量池是方法区的一部分,因此这两个区域的溢出测试就放在一起进行。方法区用于存放Class的相关信息,如类名、访问修饰符、常量池、字段描述、方法描述等,所以对于动态生成类的情况比较容易出现永久代的内存溢出。对于这些区域的测试,基本的思路是运行时产生大量的类去填满方法区,直到溢出。
/**
* (JDK 8)VM Args: -XX:MetaspaceSize=10M -XX:MaxMetaspaceSize=10m
* (JDK 7之前)VM Args: -XX:PermSize=10M -XX:MaxPermSize=10m
*/
public class MethodAreaOOM {
static class OOMClass {}
public static void main(final String[] args) {
for (;;) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(OOMClass.class);
enhancer.setUseCache(false);
enhancer.setCallback(new MethodInterceptor() {
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
return methodProxy.invokeSuper(o, objects);
}
});
enhancer.create();
}
}
}
// Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
// at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:237)
// at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:377)
// at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:285)
// at com.ankeetc.commons.Main.main(Main.java:28)
方法区溢出场景
方法区溢出也是一种常见的内存溢出异常,一个类要被垃圾收集器回收掉,判定条件是比较苛刻的。在经常动态生成大量Class的应用中,需要特别注意类的回收状况。这类场景主要有:
- 使用了CGLib字节码增强,当前的很多主流框架,如Spring、Hibernate,在对类进行增强时,都会使用到CGLib这类字节码技术,增强的类越多,就需要越大的方法区来保证动态生成的Class可以加载入内存。
- 大量JSP或动态产生JSP文件的应用(JSP第一次运行时需要编译为Java类)
- 基于OSGi的应用(即使是同一个类文件,被不同的加载器加载也会视为不同的类)等
- JVM上的动态语言(例如Groovy等)通常都会持续创建类来实现语言的动态性
2.4.4 本机直接内存溢出
下面代码越过了DirectByteBuffer
类,直接通过反射获取Unsafe
实例进行内存分配(Unsafe
类的getUnsafe()
方法限制了只有引导类加载器才会返回实例,也就是设计者希望只有rt.jar中的类才能使用Unsafe
的功能)。因为,虽然使用DirectByteBuffer
分配内存也会抛出内存溢出异常,但它抛出异常时并没有真正向操作系统申请分配内存,而是通过计算得知内存无法分配,于是手动抛出异常,真正申请分配内存的方法是unsafe.allocateMemory()
。
/**
* VM Args:-Xmx20M -XX:MaxDirectMemorySize=10M
* DirectMemory容量可通过-XX:MaxDirectMemorySize指定
* 如果不指定,则默认与Java堆最大值(-Xmx指定)一样。
*/
public class Main {
private static final long _1024MB = 1024 * 1024 * 1024;
public static void main(String[] args) throws Exception {
Field unsafeField = Unsafe.class.getDeclaredFields()[0];
unsafeField.setAccessible(true);
Unsafe unsafe = (Unsafe) unsafeField.get(null);
while (true) {
unsafe.allocateMemory(_1024MB);
}
}
}
// Exception in thread "main" java.lang.OutOfMemoryError
// at sun.misc.Unsafe.allocateMemory(Native Method)
// at com.ankeetc.commons.Main.main(Main.java:25)
DirectMemory特征
- 由
DirectMemory
导致的内存溢出,一个明显的特征是在Heap Dump
文件中不会看见明显的异常。 - 如果发现
OOM
之后Dump
文件很小,而程序中又直接或间接使用了NIO,那就可以考虑检查一下是不是这方面的原因。
2.5 不同版本的JDK
关于永久代和方法区
- 在 HotSpot VM 中 “PermGen Space” 其实指的就是方法区
- “PermGen Space” 和方法区有本质的区别。前者是 JVM 规范的一种实现(HotSpot),后者是 JVM 的规范。
- 只有 HotSpot 才有 “PermGen Space”,而对于其他类型的虚拟机,如 JRockit、J9并没有 “PermGen Space”。
不同版本JDK总结
- JDK 7之后将字符串常量池由永久代转移到堆中
- JDK 8中, HotSpot 已经没有 “PermGen space”这个区间了,取而代之是一个叫做 Metaspace(元空间) 的东西。
- 元空间的本质和永久代类似,都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于:元空间并不在虚拟机中,而是使用本地内存。因此,默认情况下,元空间的大小仅受本地内存限制。
-XX:MetaspaceSize
:初始空间大小,达到该值就会触发垃圾收集进行类型卸载。同时GC会对该值进行调整——如果释放了大量的空间,就适当降低该值;如果释放了很少的空间,那么在不超过MaxMetaspaceSize时,适当提高该值。-XX:MaxMetaspaceSize
:最大空间,默认是没有限制的。-XX:MinMetaspaceFreeRatio
:在GC之后,最小的Metaspace剩余空间容量的百分比,减少为分配空间所导致的垃圾收集-XX:MaxMetaspaceFreeRatio
:在GC之后,最大的Metaspace剩余空间容量的百分比,减少为释放空间所导致的垃圾收集PermSize
、MaxPermSize
参数已移除