JVM

类加载过程

http://www.cnblogs.com/leefreeman/p/7429112.html

我们编写的java代码，会经过编译器编译成字节码文件（class文件），再把字节码文件装载到JVM中，映射到各个内存区域中，我们的程序就可以在内存中运行了。

类加载的流程分为以上五个步骤：

1、加载

加载是类装载的第一步，首先通过class文件的路径读取到二进制流，并解析二进制流将里面的元数据（类型、常量等）载入到方法区，在java堆中生成对应的java.lang.Class对象。

2、连接

连接过程又分为3步，验证、准备、解析

2.1、验证

验证的主要目的就是判断class文件的合法性，比如class文件一定是以0xCAFEBABE开头的，另外对版本号也会做验证，例如如果使用java1.8编译后的class文件要再java1.6虚拟机上运行，因为版本问题就会验证不通过。除此之外还会对元数据、字节码进行验证，具体的验证过程就复杂的多了，可以专门查看相关资料去了解。

2.2、准备

准备过程就是分配内存，给类的一些字段设置初始值，例如：

public static int v=1;

这段代码在准备阶段v的值就会被初始化为0，只有到后面类初始化阶段时才会被设置为1。

但是对于static final（常量），在准备阶段就会被设置成指定的值，例如：

public static final  int v=1;

这段代码在准备阶段v的值就是1。

2.3、解析

解析过程就是将符号引用替换为直接引用，例如某个类继承java.lang.object，原来的符号引用记录的是“java.lang.object”这个符号，凭借这个符号并不能找到java.lang.object这个对象在哪里？而直接引用就是要找到java.lang.object所在的内存地址，建立直接引用关系，这样就方便查询到具体对象。

3、初始化

初始化过程，主要包括执行类构造方法、static变量赋值语句，staic{}语句块，需要注意的是如果一个子类进行初始化，那么它会事先初始化其父类，保证父类在子类之前被初始化。所以其实在java中初始化一个类，那么必然是先初始化java.lang.Object，因为所有的java类都继承自java.lang.Object。

类加载器

classLoader中的方法：

1. 加载类  public Class<?> loadClass(String name) throws ClassNotFoundException

2. 定义类  protected final Class<?> defineClass(byte[] b, int off, int len)

3. 查找类  protected Class<?> findClass(String name) throws ClassNotFoundException

4. 查找已加载的类  protected final Class<?> findLoadedClass(String name)

ClassLoader分类：

BootStrap Classloader (启动ClassLoader)

Extension ClassLoader （扩展ClassLoader）

App ClassLoader(应用 ClassLoader)

Custom ClassLoader(自定义ClassLoader)

每个ClassLoader都有另外一个ClassLoader作为父ClassLoader，BootStrap Classloader除外，它没有父Classloader。

ClassLoader加载机制【双亲模式】：

自下向上检查类是否被加载，一般情况下，首先从App ClassLoader中调用findLoadedClass方法查看是否已经加载，如果没有加载，则会交给父类，Extension ClassLoader去查看是否加载，还没加载，则再调用其父类，BootstrapClassLoader查看是否已经加载，如果仍然没有，自顶向下尝试加载类，那么从 Bootstrap ClassLoader到 App ClassLoader依次尝试加载。

值得注意的是即使两个类来源于相同的class文件，如果使用不同的类加载器加载，加载后的对象是完全不同的，这个不同反应在对象的 equals()、isAssignableFrom()、isInstance()等方法的返回结果，也包括了使用 instanceof 关键字对对象所属关系的判定结果。

双亲委托模式的优点：

1. 防止重复加载，当父亲已经加载了该类的时候，就没有必要子ClassLoader再加载一次。

2. 安全因素：双亲委托模式保证启动类加载器可以保证在扩展类加载器之前加载，而扩展类加载器可以保证在应用类加载器之前加载，以此类推。而这种方式可以防止不可信的类假冒信任的类。例如黑客想要混进java.lang的包，而自己写了一个java.lang.Integer的类，通过双亲委托模式就会识别这种伎俩，因为启动类加载器在核心Java API发现这个名字的类，所以他就支架加载Java核心API的java.lang.Integer类，然后将这个类返回，所以自始至终网络上的java.lang.Integer是不会被加载的。

内存空间

1. 程序计数器

每个线程都有其独立的程序计数器，这个计数器记录的是正在执行的虚拟机字节码指令的地址，此内存区域是唯一一个在Java 虚拟机规范中没有规定任何OutOfMemoryError 情况的区域。

2. JAVA栈

JAVA栈也是线程私有的，用于存放局部变量，包括编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference 类型，它不等同于对象本身，根据不同的虚拟机实现，它可能是一个指向对象起始地址的引用指针，也可能指向一个代表对象的句柄或者其他与此对象相关的位置）和returnAddress 类型（指向了一条字节码指令的地址）。

两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError 异常；如果虚拟机栈可以动态扩展（当前大部分的Java 虚拟机都可动态扩展，只不过Java 虚拟机规范中也允许固定长度的虚拟机栈），当扩展时无法申请到足够的内存时会抛出OutOfMemoryError 异常。

Java栈中又会包含多个栈帧(Stack Frame)，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，Java栈的栈顶的栈帧就是当前正在执行的活动栈，也就是当前正在执行的方法，PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用，当在这个栈帧中调用另外一个方法时，与之对应的一个新的栈帧被创建，这个新创建的栈帧被放到Java栈的栈顶，变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用，当这个栈帧中所有指令都完成时，这个栈帧被移除Java栈，刚才的那个栈帧变为活动栈帧，前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。

3. 本地方法栈

本地方法栈（Native Method Stacks）与虚拟机栈所发挥的作用是非常相似的，其区别不过是虚拟机栈为虚拟机执行Java 方法（也就是字节码）服务，而本地方法栈则是为虚拟机使用到的Native 方法服务。虚拟机规范中对本地方法栈中的方法使用的语言、使用方式与数据结构并没有强制规定，因此具体的虚拟机可以自由实现它。甚至有的虚拟机（譬如Sun HotSpot 虚拟机）直接就把本地方法栈和虚拟机栈合二为一。与虚拟机栈一样，本地方法栈区域也会抛出StackOverflowError 和OutOfMemoryError异常。

一个Native Method就是一个java调用非java代码的接口。

Native method存在的原因：java使用起来非常方便，然而有些层次的任务用java实现起来不容易，比如与java环境外交互，与操作系统的交互。

4. JAVA堆

是java虚拟机所管理的内存中最大的一块内存区域，也是被各个线程共享的内存区域，该内存区域存放了对象实例及数组（但不是所有的对象实例都在堆中）。如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError 异常。

为了方便进行垃圾回收，JAVA堆内存又分为新生代和老年代，其中新生代由一个伊甸区和2个幸存区组成，2个幸存区是大小相同，完全对称的，没有任何差别。我们把它们称为S0区和S1区，也可以称为from区和to区。

5. 方法区

方法区各线程的共享区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。因为方法区不太经常进行垃圾回收，因此也常被称为“永久代”（虽然这种说法也不太严谨）。当方法区无法满足内存分配需求时，将抛出OutOfMemoryError 异常。

在hotspot虚拟机中默认eden:survivor0:survivor1=8:1:1,每次使用一个eden和一个survior，所以相当于只浪费了10%的空间，但是并不能保证新生代每次存活下来的对象都低于10%，这时就需要老生代来进行一起分担了。

垃圾回收算法

http://www.cnblogs.com/leefreeman/p/7389919.html

stop the world会在执行某一个垃圾回收算法的时候产生，JVM为了执行垃圾回收，会暂时java应用程序的执行，等垃圾回收完成后，再继续运行。

1. 引用计数法：当对象的引用数为0时将会被清除。

缺点：频繁计数十分影响性能，也无法解决循环引用的问题

2. 标记清除法

标记：遍历所有的GC Roots，并将从GC Roots可达的对象设置为存活对象；

清除：遍历堆中的所有对象，将没有被标记可达的对象清除；

GC Roots的选择：

• 虚拟机栈中的引用对象
• 方法区中类静态属性引用的对象
• 方法区中常量引用对象
• 本地方法栈中JNI引用对象

原因：因为存活的时间长，不易被轻易清除。而栈中的引用对象是当前正在被使用的，是活跃的。

标记清除算法执行过程中，会产生“stop the world”，让java程序暂停等待以保证在标记清除的过程中，不会有新的对象产生。为什么必须暂停java程序呢？举个例子，如果在标记过程完成后，又新产生了一个对象，而该对象已经错过了标记期，那么在接下来的清除流程中，这个新产生的对象因为未被标记，所以将被视为不可达对象而被清除，这样程序就会出错，因此标记清除算法在执行时，java程序将被暂停，产生“stop the world”。

缺点：

1、因为涉及大量的内存遍历工作，所以执行性能较低，这也会导致“stop the world”时间较长，java程序吞吐量降低；

2、我们注意到对象被清除之后，被清除的对象留下内存的空缺位置，造成内存不连续，空间浪费。

 

3. 标记压缩算法

在标记清除算法的基础上，增加了压缩过程。在进行完标记清除之后，对内存空间进行压缩，节省内存空间，解决了标记清除算法内存不连续的问题。

4. 复制算法

复制算法简单来说就是把内存一分为二，但只使用其中一份，在垃圾回收时，将正在使用的那份内存中存活的对象复制到另一份空白的内存中，最后将正在使用的内存空间的对象清除，完成垃圾回收。

复制算法相对标记压缩算法来说更简洁高效，但它的缺点也显而易见，它不适合用于存活对象多的情况，因为那样需要复制的对象很多，复制性能较差，所以复制算法往往用于内存空间中新生代的垃圾回收，因为新生代中存活对象较少，复制成本较低。它另外一个缺点是内存空间占用成本高，因为它基于两份内存空间做对象复制，在非垃圾回收的周期内只用到了一份内存空间，内存利用率较低。

垃圾回收器

http://www.cnblogs.com/leefreeman/p/7402695.html

	串行收集器	并行回收器		CMS回收器
		ParNew回收器	Parallel回收器
新生代	单线程	多线程	多线程
	复制算法	复制算法	复制算法
老年代	单线程	单线程	多线程	并发
	标记压缩算法	标记压缩算法	标记压缩算法	标记清除算法

CMS回收器

1. 初始标记：标记GC Roots可以直接到达的对象[stop the world]

2. 并发标记：此时应用程序依旧在运行，并没有执行stop the world， 标记全部的对象

3. 重新标记：由于并发标记时，用户线程依然运行，因此在正式清理前，再做依次重新标记，进行修正。[stop the world]

4. 并发清除（和用户线程一起）：基于标记结果，直接清理对象。

CMS的优点显而易见，就是减少了应用程序的停顿时间，让回收线程和应用程序线程可以并发执行。但它也不是完美的，从他的运行机制可以看出，因为它不像其他回收器一样集中一段时间对垃圾进行回收，并且在回收时应用程序还是运行，因此它的回收并不彻底。这也导致了CMS回收的频率相较其他回收器要高，频繁的回收将影响应用程序的吞吐量。

G1回收器

不同于其他的回收器、G1将堆空间划分成了互相独立的区块。每块区域既有可能属于老年代、也有可能是新生代，并且每类区域空间可以是不连续的（对比CMS的老年代和新生代都必须是连续的）。这种将老年代区划分成多块的理念源于：当并发后台线程寻找可回收的对象时、有些区块包含可回收的对象要比其他区块多很多。虽然在清理这些区块时G1仍然需要暂停应用线程、但可以用相对较少的时间优先回收包含垃圾最多区块。这也是为什么G1命名为Garbage First的原因：第一时间处理垃圾最多的区块。

G1相对CMS回收器来说优点在于：

1、因为划分了很多区块，回收时减小了内存碎片的产生；

2、G1适用于新生代和老年代，而CMS只适用于老年代。