Java类加载机制

类是在运行期间第一次使用时动态加载的，而不是一次性加载所有类。因为如果一次性加载，那么会占用很多的内存。
类的生命周期：加载->验证->准备->解析->初始化->使用->卸载

类加载过程

包括加载，验证，准备，解析，初始化
1.加载

• 通过类的全限定类名获得类的二进制字节流
• 将该字节流表示的静态存储结构转换为方法区的运行时存储结构
• 在内存中生成一个代表该类的 Class 对象，作为方法区中该类各种数据的访问入口
  2.验证
  确保当前字节流包含的信息符合虚拟机的要求，并且不会危害虚拟机
  3.准备
• 如果类变量是被static修饰，准备阶段会为其分配内存和初始值(通常为0)，使用的是方法区内存，以下n初始值为0
  private static int n=111;
• 如果类变量是常量，那么初始值不会是0，以下则为n=111
  private static final int n=111;
  解析
  将常量池的符号引用替换为直接引用的过程（可选）
  初始化
  初始化阶段才真正开始执行类中定义的 Java 程序代码。初始化阶段是虚拟机执行类构造器 <clinit>() 方法的过程。在准备阶段，类变量已经赋过一次系统要求的初始值，而在初始化阶段，根据程序员通过程序制定的主观计划去初始化类变量和其它资源。
  <clinit>() 是由编译器自动收集类中所有类变量的赋值动作和静态语句块中的语句合并产生的，编译器收集的顺序由语句在源文件中出现的顺序决定。特别注意的是，静态语句块只能访问到定义在它之前的类变量，定义在它之后的类变量只能赋值，不能访问。例如以下代码
  public class Test {
static {
i=0;
System.out.println(i);//非法向前引用
}
public static int i = 1;
}

类初始化时机

1. 主动引用

• 遇到new关键字实例化对象
• 读取或者设置一个类的静态字段
• 调用一个类的静态方法
• 使用反射调用的时候，如果该类没有初始化，先触发对其的初始化
• 初始化一个类时，如果其父类没有初始化先初始化其父类
• 虚拟机启动时，用户指定一个执行的类（包含main()方法那个类）
  2. 被动引用
• 通过子类调用父类的静态字段不会导致父类的初始化
• 通过数组定义来引用类，不会触发此类的初始化。该过程会对数组类进行初始化，数组类是一个由虚拟机自动生成的、直接继承自 Object 的子类，其中包含了数组的属性和方法。
• 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。

类与类加载器

  两个类相等，需要类本身相等，并且使用同一个类加载器进行加载。这是因为每一个类加载器都拥有一个独立的类名称空间。这里的相等，包括类的 Class 对象的 equals() 方法、isAssignableFrom() 方法、isInstance() 方法的返回结果为true，也包括使用 instanceof 关键字做对象所属关系判定结果为 true。
  类加载器分类

• 启动类加载器（Bootstrap ClassLoader）此类加载器负责将存放在 <JRE_HOME>\lib 目录中的，或者被 -Xbootclasspath 参数所指定的路径中的，并且是虚拟机识别的（仅按照文件名识别，如 rt.jar，名字不符合的类库即使放在 lib 目录中也不会被加载）类库加载到虚拟机内存中。启动类加载器无法被 Java 程序直接引用，用户在编写自定义类加载器时，如果需要把加载请求委派给启动类加载器，直接使用 null 代替即可。
• 扩展类加载器（Extension ClassLoader）这个类加载器是由ExtClassLoader（sun.misc.Launcher$ExtClassLoader）实现的。它负责将 <JAVA_HOME>/lib/ext 或者被java.ext.dir 系统变量所指定路径中的所有类库加载到内存中，开发者可以直接使用扩展类加载器。
• 应用程序类加载器（Application ClassLoader）这个类加载器是由AppClassLoader（sun.misc.Launcher$AppClassLoader）实现的。由于这个类加载器是 ClassLoader 中的getSystemClassLoader() 方法的返回值，因此一般称为系统类加载器。它负责加载用户类路径（ClassPath）上所指定的类库，开发者可以直接使用这个类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

双亲委派模型

我们的应用程序都是由这三种加载器互相配合进行加载的，如果有必要，还可以加入自定义的类加载器。
这些类加载器的关系一般如下图所示

上图展示的类加载器之间的这种层次关系，就称为类加载器的双亲委派模型。双亲委派模型要求除了顶层的父类加载器外，其余的类加载器都应有自己的父类加载器。

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

类加载器的双亲委派模型从JDK1.2引入后被广泛应用于之后几乎所有的Java程序中，但它并不是强制性约束，甚至可以破坏双亲委派模型来进行类加载，最典型的就是OSGI技术。

双亲委派模式对于保证Java程序的稳定运行很重要。有一个显而易见的好处就是Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如java.lang.Object类，它存放在rt.jar中，无论哪一个类加载器要加载这个类，最终都是委派给处于顶端的启动类加载器进行加载。因此，Object类在程序的各种类加载器环境中都是同一个类.
ClassLoader.loadClass()方法

  protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            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) {
                // If still not found, then invoke findClass in order
                // to find the class.
                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;
    }
}

自定义类加载器

public class MyClassLoader extends ClassLoader {
    private String rootDir;
public MyClassLoader(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 name) {
    String dir = getRealDir(name);
    FileInputStream fileInputStream = null;
    try {
        fileInputStream = new FileInputStream(dir);
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        byte[] bytes = new byte[2048];
        int n;
        while ((n = fileInputStream.read(bytes)) != -1) {
            outputStream.write(bytes, 0, n);
        }
        return outputStream.toByteArray();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;
}

private String getRealDir(String name) {
    return rootDir + "\\" + name + ".class";
}
}