来源：《深入理解Java虚拟机(第2版)》

Java虚拟机-类,对象，内存

类加载

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。

虚拟机规定了有且只有五种情况需要开始类的加载过程:

遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：使用new关键字实例化对象的时候，读取或设置一个类的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候，以及调用一个类的静态方法的时候。
使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。
当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
当使用JDK 1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

这五种场景中的行为称为对一个类的主动引用，其他情况称为被动引用，

//被动引用示例一: 使用子类引用父类的静态字段，不会导致子类初始化。
public class SuperClass {
    public static int value = 123;
    static {
        System.out.println("super class init.");
    }
}

public class SubClass extends SuperClass {
    static {
        System.out.println("sub class init.");
    }
}

public static void main(String[] args) {    
    System.out.println(SubClass.value);
}

//输出：
super class init.

//被动引用示例二：通过数组定义来引用类，不会触发类的初始化
public static void main(String[] args) {
        SuperClass[] arr = new SuperClass[10];
}

public class SuperClass {
    public static int value = 123;
    static {
        System.out.println("super class init.");
    }
}

//输出
nonthing

//被动引用示例三：常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。
public static void main(String[] args) {
        System.out.println(ConstClass.Test);
}

public class ConstClass {
    public static final String Test = "Hello world!";

    static {
        System.out.println("const class init.");
    }
}

//输出
Hello world!

类加载的过程

java虚拟机中类加载的全过程：加载、验证、准备、解析和初始化这5个阶段，注意区别于类的生命周期。

加载

在加载阶段，虚拟机需要完成以下3件事情：

1）通过一个类的全限定名来获取定义此类的二进制字节流。
2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3）在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

数组类本身不通过类加载器创建，它是由java虚拟机直接创建的。但数组类与类加载器仍然有密切的关系，因为数组类的元素类型（Element Type，指的是数组去掉所有维度的类型）最终是要靠类加载器去创建。

加载阶段与连接阶段的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在加载阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

验证

验证是连接阶段（连接阶段包括验证、准备、解析）的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。如果验证失败，会抛出java.lang.VerifyError异常。

验证阶段大致上会完成下面4个阶段的检验动作：文件格式验证、元数据验证、字节码验证、符号引用验证。

准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。这个阶段中有两个容易产生混淆的概念需要强调一下，首先，这时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在java堆中。其次，这里所说的初始值“通常情况下“是数据类型的零值。假设一个类变量的定义为：

1	public static int value=123;

那变量value在准备阶段过后的初始值为0而不是123

如果类字段的字段属性表中存在ConstantValue属性，那在准备阶段变量value就会被初始化为ConstantValue属性所指定的值，假设上面类变量value的定义变为：

1	public static final int value=123;

编译时javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置讲value赋值为123。

解析

解析阶段时虚拟机将常量池内的符号引用替换为直接引用的过程。

符号引用：符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须都是一致的，因为符号引用的字面量形式明确定义在java虚拟机规范的Class文件格式中。

直接引用：直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用是和虚拟机实现的内存布局相关的，同一个符号引用在不同虚拟机实例上翻译出来的直接引用一般不会相同。如果有了直接引用，那直接引用的目标必定已经在内存中存在。

解析的动作主要针对类或接口、字段、类方法、接口方法四类符号引用进行解析。

初始化

在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序员制定的主观计划去初始化类变量和其他资源，或者从另一个角度来表达：初始化阶段是执行类构造器< clinit >()方法的过程。

关于< clinit >：

< clinit >方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量。

类构造器< clinit >方法对于类和接口并不是必须的，如果一个类中没有静态初始化块，也没有类变量赋值操作，则编译器可以不为该类生成类构造器< clinit >方法。
java虚拟机会保证一个类的< clinit >方法在多线程环境中被正确地加锁和同步，如果多个线程同时去初始化一个类，只会有一个线程去执行这个类的< clinit >方法，其他线程都需要阻塞等待，直到活动线程执行< clinit >方法完毕。

初始化阶段，当执行完类构造器< clinit >方法之后，才会执行实例构造器的< init >方法，实例构造方法同样是按照先父类，后子类，先成员变量，后实例构造方法的顺序执行。

类加载器

类与类加载器

对于任何一个类，都需要由加载它的类加载器和这个类来确立其在JVM中的唯一性。也就是说，两个类来源于同一个Class文件，并且被同一个类加载器加载，这两个类才相等。

双亲委派模型

从虚拟机的角度来说，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），该类加载器使用C++语言实现，属于虚拟机自身的一部分。另外一种就是所有其它的类加载器，这些类加载器是由Java语言实现，独立于JVM外部，并且全部继承自抽象类java.lang.ClassLoader。

从Java开发人员的角度来看，大部分Java程序一般会使用到以下三种系统提供的类加载器：

启动类加载器（Bootstrap ClassLoader）：负责加载JAVA_HOME\lib目录中并且能被虚拟机识别的类库到JVM内存中，如果名称不符合的类库即使放在lib目录中也不会被加载。该类加载器无法被Java程序直接引用。
扩展类加载器（Extension ClassLoader）：该加载器主要是负责加载JAVA_HOME\lib\，该加载器可以被开发者直接使用。
应用程序类加载器（Application ClassLoader）：该类加载器也称为系统类加载器，它负责加载用户类路径（Classpath）上所指定的类库，开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

在Android系统中，情况有所不同,SecureClassLoader和UrlClassLoader是在Java中的类加载器，在Android中是没法办使用的:

其中，App系统类加载器是PathClassLoader，而BootClassLoader是其parent类加载器。

双亲委派模型的工作过程为：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的加载器都是如此，因此所有的类加载请求都会传给顶层的启动类加载器，只有当父加载器反馈自己无法完成该加载请求（该加载器的搜索范围中没有找到对应的类）时，子加载器才会尝试自己去加载。

自定义类加载器

/**   代码来自 http://blog.csdn.net/boyupeng/article/details/47951037
     * 一、ClassLoader加载类的顺序 
     *  1.调用 findLoadedClass(String) 来检查是否已经加载类。 
     *  2.在父类加载器上调用 loadClass 方法。如果父类加载器为 null，则使用虚拟机的内置类加载器。 
     *  3.调用 findClass(String) 方法查找类。 
     * 二、实现自己的类加载器 
     *  1.获取类的class文件的字节数组 
     *  2.将字节数组转换为Class类的实例 
     */  
    public class ClassLoaderTest {  
        public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {  
            //新建一个类加载器  
            MyClassLoader cl = new MyClassLoader("myClassLoader");  
            //加载类，得到Class对象  
            Class<?> clazz = cl.loadClass("classloader.Animal");  
            //得到类的实例  
            Animal animal=(Animal) clazz.newInstance();  
            animal.say();  
        }  
    }  
    class Animal{  
        public void say(){  
            System.out.println("hello world!");  
        }  
    }  
    class MyClassLoader extends ClassLoader {  
        //类加载器的名称  
        private String name;  
        //类存放的路径  
        private String path = "E:\\workspace\\Algorithm\\src";  
        MyClassLoader(String name) {  
            this.name = name;  
        }  
        MyClassLoader(ClassLoader parent, String name) {  
            super(parent);  
            this.name = name;  
        }  
        /** 
         * 重写findClass方法 
         */  
        @Override  
        public Class<?> findClass(String name) {  
            byte[] data = loadClassData(name);  
            return this.defineClass(name, data, 0, data.length);  
        }  
        public byte[] loadClassData(String name) {  
            try {  
                name = name.replace(".", "//");  
                FileInputStream is = new FileInputStream(new File(path + name + ".class"));  
                ByteArrayOutputStream baos = new ByteArrayOutputStream();  
                int b = 0;  
                while ((b = is.read()) != -1) {  
                    baos.write(b);  
                }  
                return baos.toByteArray();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
    }

对象

对象的创建

当虚拟机遇到一条new指令时，首先会去检查这个类的符号引用是否可以在常量池中定位，这个类是否已经被加载解析和初始化过。
检查通过后，虚拟机开始为新生的对象分配内存。分配内存通常有两种方式：
- 如果Java堆中内存是绝对规整的，所有用过的内存都放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，这种分配方式称为“指针碰撞”。
- 如果Java堆中的内存并不是规整的，已使用的内存和空闲的内存相互交错，虚拟机就必须维护一个列表，记录那些内存块是可用的，这种分配方式成为“空闲列表”。采用哪种方式和虚拟机的GC类型有关。
内存分配完成后。虚拟机需要将这块内存空间初始化为零值。此时一个新的对象已经诞生了，然后是执行<init>方法，按照程序员的意愿进行初始化，之后才可用。

对象的内存布局

对象在内存中存储的布局可以分为三块区域：对象头，实例数据和对齐填充。

对象头包含两部分信息，一部分用来存储对象自身的运行时数据,包括对象的哈希码，gc分代年龄，锁状态标识，线程锁等，称为Mark Word（在32bit和64bit虚拟机上长度分别为32bit和64bit）；另一部分是类型指针，指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例，并不是所有的虚拟机实现都必须在对象数据上保留类型指针。另外，如果对象是一个Java数组，那么对象头重还会记录数组的长度。
实例数据是对象真正存储信息的地方,也是代码中所定义的各种类型的字段内容.无论是继承下来的,还是子类中定义的,都需要记录起来.
对齐填充并不是必然存在的，因为虚拟机要对对象的大小必须是8的整数倍，因此，它仅仅用来对齐。

对象的访问定位

Java程序需要通过栈上的引用数据来操作堆上的具体对象。对象的访问方式取决于虚拟机实现，目前主流的访问方式有使用句柄和直接指针两种。

句柄，可以理解为指向指针的指针，维护指向对象的指针变化，而对象的句柄本身不发生变化；指针，指向对象，代表对象的内存地址。

句柄

Java堆中划分出一块内存来作为句柄池，引用中存储对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息。

优势：引用中存储的是稳定的句柄地址，在对象被移动(垃圾收集时移动对象是非常普遍的行为)时只会改变句柄中的实例数据指针，而引用本身不需要修改。

直接指针

如果使用直接指针访问，那么Java堆对象的布局中就必须考虑如何放置访问类型数据的相关信息，而引用中存储的直接就是对象地址。优势：速度更快，节省了一次指针定位的时间开销。由于对象的访问在Java中非常频繁，因此这类开销积少成多后也是非常可观的执行成本。（例如HotSpot）

运行时内存区域划分

根据《Java虚拟机规范(SE 7)》的规定，Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不用的区域。

程序计数器

程序计数器可以看作当前线程所执行的字节码的行号指示器，在任何一个确定的时刻，一个处理器都只会执行一条线程中的指令，因此，为什么线程切换后能恢复到正确的执行位置，每条线程都需要一个独立的程序计数器，它们互不影响，存储在线程私有内存区域。此区域是唯一一个在java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

Java虚拟机栈

和程序计数器一样，Java虚拟机栈也是线程私有的，每一个Java方法执行的时候，都会创建一个栈帧，它的生命周期很短，主要用于存储局部变量，操作数栈，动态链接，方法出口地址等，此区域可能会抛出StackOverFlow异常和OutOfMemoryError异常。还会保存堆中对象变量的引用。

本地方法栈

和Java虚拟机栈的作用类似，为Native方法服务，线程私有。

Java堆

Java堆是被所有的线程共享的一块内存区域，此区域的唯一目的就是存放对象实例，几乎所有的对象实例和数组都会在这里分配。Java堆是GC管理的主要区域。由于现在GC基本都采用分代收集算法，所以Java堆还可以细分为新生代和老年代；再细致点就是Eden，From Survivor,To Survivor空间等。可以通过-Xmx和-Xms来进行大小的扩展。堆内存的生命周期从程序的运行开始到运行结束。

方法区

方法区也是被所有线程共享的内存区域，它用于存储已经被虚拟机加载的类信息，常量，静态变量等。

运行时常量池

方法区的一部分

直接内存

直接内存并不是虚拟机运行时数据区的一部分。它使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆中的DirectByteBuffer对象作为这块内存的引用进行操作，避免了在Java堆和Native堆中来回复制数据。虽然直接内存的分配不受Java虚拟机的限制，但是它仍然受到物理内存总大小等的限制，当Java堆过大的时候，可能会导致这块区域分配不足而OutOfMemory异常。

图片来源于http://gityuan.com/2016/01/09/java-memory/