JVM性能优化专题（一）

一、Java类加载过程

Java类加载需要经历一下7个过程：

1 .加载

加载是类加载的第一个过程，在这个阶段，将完成以下三件事情:

•通过一个类的全限定名获取该类的二进制流。

•将该二进制流中的静态存储结构转化为方法去运行时数据结

构。

•在内存中生成该类的Class对象，作为该类的数据访问入口。

2 .验证

验证的目的是为了确保Class文件的字节流中的信息不会危害到 虚拟机.在该阶段主要完成以下四种验证： •文件格式验证：验证字节流是否符合Class文件的规范，如主次版本号 是否在当前虚拟机范围内，常量池中的常量是否有不被支持的类型.

•元数据验证:对字节码描述的信息进行语义分析，如这个类是否有父类， 是否集成了不被继承的类等。

•字节码验证：是整个验证过程中最复杂的一个阶段，通过验证数据流和 控制流的分析，确定程序语义是否正确，主要针对方法体的验证。如：方 法中的类型转换是否正确，跳转指令是否正确等。

•符号引用验证：这个动作在后面的解析过程中发生，主要是为了确保解 析动作能正确执行。

3 .准备

准备阶段是为类的静态变量分配内存并将其初始化为默认值，这些内存都 将在方法区中进行分配。准备阶段不分配类中的实例变量的内存，实例变 量将会在对象实例化时随着对象一起分配在Java堆中。

public static int value=123;〃在准备阶段value初始值为0。在初始化阶 段才会变为123。

4 .解析

该阶段主要完成符号引用到直接引用的转换动作。解析动作并不一定在初 始化动作完成之前，也有可能在初始化之后。

5 .初始化

初始化时类加载的最后一步，前面的类加载过程，除了在加载阶段用户应 用程序可以通过自定义类加载器参与之外，其余动作完全由虚拟机主导和 控制。到了初始化阶段，才真正开始执行类中的定义的java程序代码。

6. 使用

7. 卸载

二、 java内存分配

•寄存器：我们无法控制。

•静态域：static定义的静态成员。

•常量池：编译时被确定并保存在.class文件中的（final）常量值和 一些文本修饰的符号引用（类和接口的全限定名，字段的名称和描述符， 方法和名称和描述符）。

•非RAM存储：硬盘等永久存储空间。

•堆内存：new创建的对象和数组，由Java虚拟机自动垃圾回收器管理， 存取速度慢。

•栈内存：基本类型的变量和对象的引用变量（堆内存空间的访问地 址），速度快，可以共享，但是大小与生存期必须确定，缺乏灵活性。

I.Java堆的结构是什么样子的？什么是堆中的永久代（Perm Gen space） ?

JVM的堆是运行时数据区，所有类的实例和数组都是在堆上分配内存。它 在JVM启动的时候被创建。对象所占的堆内存是由自动内存管理系统也就 是垃圾收集器回收。

堆内存是由存活和死亡的对象组成的。存活的对象是应用可以访问的，不 会被垃圾回收。死亡的对象是应用不可访问尚且还没有被垃圾收集器回收 掉的对象。一直到垃圾收集器把这些对象回收掉之前，他们会一直占据堆内存空间。

3、 描述一下JVM加载Class文件的原理机制？

Java语言是一种具有动态性的解释型语言，类（Class）只有被加载到JVM后才能运行。当运行指定程序时，JVM会将编译生成的.class 文件按照需求和一定的规则加载到内存中，并组织成为一个完整的Java应 用程序。这个加载过程是由类加载器完成，具体来说，就是由 ClassLoader和它的子类来实现的。类加载器本身也是一个类，其实质是 把类文件从硬盘读取到内存中。

类的加载方式分为隐式加载和显示加载。隐式加载指的是程序在使用new 等方式创建对象时，会隐式地调用类的加载器把对应的类加载到JVM中。 显示加载指的是通过直接调用class.forName()方法来把所需的类加载 到JVM中。

任何一个工程项目都是由许多类组成的，当程序启动时，只把需要的类加 载到JVM中，其他类只有被使用到的时候才会被加载，采用这种方法一方 面可以加快加载速度，另一方面可以节约程序运行时对内存的开销。此 外，在Java语言中，每个类或接口都对应一个.class文件，这些文件 可以被看成是一个个可以被动态加载的单元，因此当只有部分类被修改 时，只需要重新编译变化的类即可，而不需要重新编译所有文件，因此加 快了编译速度。

在Java语言中，类的加载是动态的，它并不会一次性将所有类全部加载后再运行，而是保证程序运行的基础类(例如基类)完全加 载到JVM中，至于其他类，则在需要的时候才加载。

类加载的主要步骤：

•装载。根据查找路径找到相应的class文件，然后导入。

•链接。链接又可分为3个小步：

•检查，检查待加载的c lass文件的正确性。

•准备，给类中的静态变量分配存储空间。

•解析，将符号引用转换为直接引用(这一步可选)

•初始化。对静态变量和静态代码块执行初始化工作。

4、GC是什么？为什么要有GC?

GC是垃圾收集的意思(GabageCollection),内存处理是编程人员容易出现 问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自 动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

5、简述Java垃圾回收机制。 在Java中，程序员是不需要显示的去释放一个对象的内存的，而是由虚拟机自行执行。在JVM中，有一个垃圾回收线程，它是低优先级的，在 正常情况下是不会执行的，只有在虚拟机空闲或者当前堆内存不足时，才会触发执行，扫面那些没有被任何引用的对象，并将它们添加到要回收的集合中，进行回收。

6、如何判断一个对象是否存活?(或者GC对象的判定方法)

判断一个对象是否存活有两种方法：

1 .引用计数法

所谓引用计数法就是给每一个对象设置一个引用计数器，每当有一个地方 引用这个对象时，就将计数器加一，引用失效时，计数器就减一。当一个 对象的引用计数器为零时，说明此对象没有被引用，也就是“死对象”，将会被垃圾回收.

引用计数法有一个缺陷就是无法解决循环引用问题，也就是说当对象A 引用对象B,对象B又引用者对象A,那么此时A、B对象的引用计数器 都不为零，也就造成无法完成垃圾回收，所以主流的虚拟机都没有采用这种算法。

2 .可达性算法(引用链法)

该算法的思想是:从一个被称为GC Roots的对象开始向下搜索，如果一 个对象到GC Roots没有任何引用链相连时，则说明此对象不可用。

在Java中可以作为GC Roots的对象有以下几种：

•虚拟机栈中引用的对象

•方法区类静态属性引用的对象•方法区常量池引用的对象

•本地方法栈JNI引用的对象

虽然这些算法可以判定一个对象是否能被回收，但是当满足上述条件时， 一个对象比不一定会被回收。当一个对象不可达GC Root时，这个对象并 不会立马被回收，而是处于一个死缓的阶段，若要被真正的回收需要经历两次标记.

如果对象在可达性分析中没有与GC Root的引用链，那么此时就会被第 一次标记并且进行一次筛选，筛选的条件是是否有必要执行

finalize()方法。当对象没有覆盖finalize()方法或者已被虚拟机 调用过，那么就认为是没必要的。如果该对象有必要执行finalize() 方法，那么这个对象将会放在一个称为F-Queue的对队列中，虚拟机会 触发一个Finalize()线程去执行，此线程是低优先级的，并且虚拟机 不会承诺一直等待它运行完，这是因为如果finalize。执行缓慢或者发生了 死锁，那么就会造成F-Queue队列一直等待，造成了内存回收系统的崩 溃。GC对处于F-Queue中的对象进行第二次被标记，这时，该对象将被 移除''即将回收''集合，等待回收。

7、 垃圾回收的优点和原理。并考虑2种回收机制。

Java语言中一个显著的特点就是引入了垃圾回收机制，使C++程序员最 头疼的内存管理的问题迎刃而解，它使得Java程序员在编写程序的时候 不再需要考虑内存管理。由于有个垃圾回收机制，Java中的对象不再 有'作用域"的概念，只有对象的引用才有"作用域"。垃圾回收可以有效的 防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个 单独的低级别的线程运行，不可预知的情况下对内存堆中已经死亡的或者 长时间没有使用的对象进行清除和回收，程序员不能实时地调用垃圾回收 器对某个对象或所有对象进行垃圾回收。

回收机制有分代复制垃圾回收和标记垃圾回收，增量垃圾回收。

8、 垃圾回收器的基本原理是什么?垃圾回收器可以马上回收内存吗？ 有什么办法主动通知虚拟机进行垃圾回收？

对于GC来说，当程序员创建对象时，GC就开始监控这个对象的地址、 大小以及使用情况。通常，GC采用有向图的方式记录和管理堆(heap)中 的所有对象。通过这种方式确定哪些对象是”可达的"，哪些对象是”不可达 的”。当GC确定一些对象为“不可达”时，GC就有责任回收这些内存空 间。可以。程序员可以手动执行System.gc()，通知GC运行，但是 Java语言规范并不保证GC 一定会执行。

9、 Java中会存在内存泄漏吗，请简单描述。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存 中。Java中有垃圾回收机制，它可以保证一对象不再被引用的时候，即 对象变成了孤儿的时候，对象将自动被垃圾回收器从内存中清除掉。由于 Java使用有向图的方式进行垃圾回收管理，可以消除引用循环的问题， 例如有两个对象，相互引用，只要它们和根进程不可达的，那么GC也是 可以回收它们的，例如下面的代码可以看到这种情况的内存回收：

import java.io.IOException; public class GarbageTest {

/**

* @param args

* @throws IOException

*/

public static void main(String[] args) throws lOException {

// TODO Auto-generated method stub

try { gcTest();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("has exited gcTest!"); System.in.read();

System.in.read(); System.out.println("out begin gc!"); for(int i=0;i<100;i++)

{

System.gc();

System.in.read();

System.in.read(); }

}

private static void gcTest() throws IOException {

System.in.read();

System.in.read();

Person p1 = new Person(); System.in.read();

System.in.read();

Person p2 = new Person();

p1.setMate(p2);

p2.setMate(p1);

System.out.println("before exit gctest!"); System.in.read(); System.in.read();

System.gc(); System.out.println("exit gctest!");

}

private static class Person {

byte[] data = new byte[20000000]; Person mate = null;

public void setMate(Person other) {

mate = other;

}

}

}

Java中的内存泄露的情况:长生命周期的对象持有短生命周期对象的引用 就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长 生命周期对象持有它的引用而导致不能被回收，这就是Java中内存泄露 的发生场景，通俗地说，就是程序员可能创建了一个对象，以后一直不再 使用这个对象，这个对象却一直被引用，即这个对象无用但是却无法被垃 圾回收器回收的，这就是java中可能出现内存泄露的情况，例如，缓存系 统，我们加载了一个对象放在缓存中（例如放在一个全局map对象中）， 然后一直不再使用它，这个对象一直被缓存引用，但却不再被使用。

检查Java中的内存泄露，一定要让程序将各种分支情况都完整执行到程 序结束，然后看某个对象是否被使用过，如果没有，则才能判定这个对象属于内存泄露。

如果一个外部类的实例对象的方法返回了一个内部类的实例对象，这个内 部类对象被长期引用了，即使那个外部类实例对象不再被使用，但由于内 部类持久外部类的实例对象，这个外部类对象将不会被垃圾回收，这也会造成内存泄露。

下面内容来自于网上（主要特点就是清空堆栈中的某个元素，并不是彻底 把它从数组中拿掉，而是把存储的总数减少，本人写得可以比这个好，在拿掉某个元素时，顺便也让它从数组中消失，将那个元素所在的位置的值设置为null即可）：

我实在想不到比那个堆栈更经典的例子了，以致于我还要引用别人的例 子，下面的例子不是我想到的，是书上看到的，当然如果没有在书上看到，可能过一段时间我自己也想得到，可是那时我说是我自己想到的也没 有人相信的。

public class Stack {

private Object[] elements=new Object[10]; private int size = 0 public void push(Object e){

ensureCapacity();

elements[size++] = e;

}

public Object pop(){

if( size == 0) throw new EmptyStackException(); return element

s[一size];

}

private void ensureCapacity(){ if(elements.length == size){ Object[] oldElements = elements;

elements = new Object[2 * elements.length+1]; System.arraycopy (oldElements,。， elements, 0,

size);

}

}

}

上面的原理应该很简单，假如堆栈加了 10个元素，然后全部弹出来，虽 然堆栈是空的，没有我们要的东西，但是这是个对象是无法回收的，这个 才符合了内存泄露的两个条件:无用，无法回收。但是就是存在这样的东 西也不一定会导致什么样的后果，如果这个堆栈用的比较少，也就浪费了 几个K内存而已，反正我们的内存都上G 了，哪里会有什么影响，再说 这个东西很快就会被回收的，有什么关系。下面看两个例子。

public class Bad{

public static Stack s=Stack(); static{

s.push(new Object());

s.pop(); //这里有一个对象发生内存泄露

s.push(new Object()); 〃上面的对象可以被回收了，等于是自愈了

}

}

因为是static,就一直存在到程序退出，但是我们也可以看到它有自愈功能，就是说如果你的Stack最多有100个对象，那么最多也就只有100 个对象无法被回收其实这个应该很容易理解，Stack内部持有100个引用，最坏的情况就是他们都是无用的，因为我们一旦放新的进取，以前的引用自然消失！

内存泄露的另外一种情况:当一个对象被存储进HashSet集合中以后，就 不能修改这个对象中的那些参与计算哈希值的字段了，否则U,对象修改后 的哈希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情 况下，即使在contains方法使用该对象的当前引用作为的参数去 HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法 从HashSet集合中单独删除当前对象，造成内存泄露。