深入研究Java类加载机制

深入研究Java类加载机制

 

类加载是Java程序运行的第一步，研究类的加载有助于了解JVM执行过程，并指导开发者采取更有效的措施配合程序执行。

研究类加载机制的第二个目的是让程序能动态的控制类加载，比如热部署等，提高程序的灵活性和适应性。

 

一、简单过程

 

Java程序运行的场所是内存，当在命令行下执行：

java HelloWorld

命令的时候，JVM会将HelloWorld.class加载到内存中，并形成一个Class的对象HelloWorld.class。

其中的过程就是类加载过程：

1、寻找jre目录，寻找jvm.dll，并初始化JVM；

2、产生一个Bootstrap Loader（引导类加载器）；

3、Bootstrap Loader自动加载Extended Loader（标准扩展类加载器），并将其父Loader设为Bootstrap Loader。

4、Bootstrap Loader自动加载AppClass Loader（系统类加载器），并将其父Loader设为Extended Loader。

5、最后由AppClass Loader加载HelloWorld类。

 

以上就是类加载的最一般的过程。

 

图示：

 

 

二、各种类加载器解释：

1、Bootstrap Loader（引导类加载器）：加载System.getProperty("sun.boot.class.path")所指定的路径或jar。

2、Extended Loader（标准扩展类加载器ExtClassLoader）：加载System.getProperty("java.ext.dirs")所指定的路径或jar。在使用Java运行程序时，也可以指定其搜索路径，例如：java -Djava.ext.dirs=d:\projects\testproj\classes HelloWorld

 

3、AppClass Loader（系统类加载器AppClassLoader）：加载System.getProperty("java.class.path")所指定的路径或jar。在使用Java运行程序时，也可以加上-cp来覆盖原有的Classpath设置，例如： java -cp ./lavasoft/classes HelloWorld

 

ExtClassLoader和AppClassLoader在JVM启动后，会在JVM中保存一份，并且在程序运行中无法改变其搜索路径。如果想在运行时从其他搜索路径加载类，就要产生新的类加载器。

 

三、类加载器的特点

 

1、运行一个程序时，总是由AppClass Loader（系统类加载器）开始加载指定的类。

2、在加载类时，每个类加载器会将加载任务上交给其父，如果其父找不到，再由自己去加载。(双亲委派机制)
3、Bootstrap Loader（引导类加载器）是最顶级的类加载器了，其父加载器为null.

 

四、类加载器的获取

很容易，看下面例子

public class HelloWorld { 
        public static void main(String[] args) { 
                HelloWorld hello = new HelloWorld(); 
                Class c = hello.getClass(); 
                ClassLoader loader = c.getClassLoader(); 
                System.out.println(loader); 
                System.out.println(loader.getParent()); 
                System.out.println(loader.getParent().getParent()); 
        } 
}

 打印结果：

sun.misc.Launcher$AppClassLoader@19821f 
sun.misc.Launcher$ExtClassLoader@addbf1 
null 

Process finished with exit code 0

 从上面的结果可以看出，并没有获取到ExtClassLoader的父Loader，原因是Bootstrap Loader（引导类加载器）是用C语言实现的，找不到一个确定的返回父Loader的方式，于是就返回null。

 

五、类的加载

 

类加载有三种方式：

1、命令行启动应用时候由JVM初始化加载

2、通过Class.forName()方法动态加载

3、通过ClassLoader.loadClass()方法动态加载

 

三种方式区别比较大，看个例子就明白了：

public class HelloWorld { 
        public static void main(String[] args) throws ClassNotFoundException { 
                ClassLoader loader = HelloWorld.class.getClassLoader(); 
                System.out.println(loader); 
                //使用ClassLoader.loadClass()来加载类，不会执行初始化块 
                loader.loadClass("Test2"); 
                //使用Class.forName()来加载类，默认会执行初始化块 
//                Class.forName("Test2"); 
                //使用Class.forName()来加载类，并指定ClassLoader，初始化时不执行静态块 
//                Class.forName("Test2", false, loader); 
        } 
}

public class Test2 { 
        static { 
                System.out.println("静态初始化块执行了！"); 
        } 
}

分别切换加载方式，会有不同的输出结果。

 

六、Class.forName()和ClassLoader.loadClass()区别

 

Class.forName()：将类的.class文件加载到jvm中之外，还会对类进行解释，执行类中的static块；

ClassLoader.loadClass()：只干一件事情，就是将.class文件加载到jvm中，不会执行static中的内容,只有在newInstance才会去执行static块。

注：

Class.forName(name, initialize, loader)带参函数也可控制是否加载static块。并且只有调用了newInstance()方法采用调用构造函数，创建类的对象 。

示例：

1.使用classLoader加载

System.out.println("before loadClass... "); 
Class c =Test.class.getClassLoader().loadClass("com.hundsun.test.ClassInfo"); 
System.out.println("after loadClass... "); 
System.out.println("before newInstance... "); 
ClassInfo info1 =(ClassInfo) c.newInstance(); 
System.out.println("after newInstance... "); 

输出结果: 
before loadClass... 
after loadClass... 
before newInstance... 
static invoked... 
contruct invoked... 
after newInstance... 

 2.使用class.forName进行加载 

System.out.println("before class.forName"); 
Class cc =Class.forName("com.hundsun.test.ClassInfo"); 
System.out.println("after class.forName"); 
ClassInfo info2 =(ClassInfo) cc.newInstance(); 

输出结果： 
before class.forName 
static invoked... 
after class.forName 
before newInstance... 
contruct invoked... 
after newInstance... 

 

下面说一下两者具体的执行过程 ：

 

LoadClass（）方法加载类及初始化过程： 
类加载（loadclass（））（加载）——》newInstance（）（链接+初始化） 
newInstance（）: 
（开始连接）静态代码块——》普通变量分配准备（a=0;b=0;c=null）——》（开始初始化）普通变量赋值（a=1;b=2;c=”haha”）——》构造方法——》初始化成功。 


Class.forName(Stirng className)一个参数方法加载类及初始化过程： 
类加载(Class.forName())（加载）——》静态代码块——》newInstance（）（链接+初始化） 

newInstance（）： 
（开始连接）普通变量分配准备（a=0;b=0;c=null）——》（开始初始化）普通变量赋值（a=1;b=2;c=”haha”）——》构造方法——》初始化成功。 

Class.forName()三个参数的加载类及初始化过程同classLoader一样。 

 

从上边的断点调试可以看出，静态代码块不是在初始化阶段完成的，它陷于类初始化，先于普通变量默认分配（整型分配为0，字符串分配为null），这也就是为什么我们不能在静态代码块中引用普通变量的原因之一，这与上面所谓的“分配”、“初始化”相违背。 

 

所以我觉得JVM的类加载及初始化过程应该是这样的： 

1. 类加载：Bootstrap Loader——》Extended Loader——》System Loader 
2. 静态代码块初始化 
3. 链接： 
a) 验证：是否符合java规范 
b) 准备：默认初始值 
c) 解析：符号引用转为直接引用，解析地址 
4. 初始化 
a) 赋值：java代码中的初始值 
b) 构造:构造函数 

 

 

有关ClassLoader还有很重要一点：

同一个ClassLoader加载的类文件，只有一个Class实例。但是，如果同一个类文件被不同的ClassLoader载入，则会有两份不同的ClassLoader实例（前提是着两个类加载器不能用相同的父类加载器）。

 

 

ClassLoader源码分析：（双亲委派机制原理）

public Class<?> loadClass(String name)throws ClassNotFoundException {

        return loadClass(name, false);

}

protectedsynchronized Class<?> loadClass(String name, boolean resolve)

            throws ClassNotFoundException {

        // 首先判断该类型是否已经被加载

        Class c = findLoadedClass(name);

        if (c == null) {

            //如果没有被加载，就委托给父类加载或者委派给启动类加载器加载

            try {

                if (parent != null) {

//如果存在父类加载器，就委派给父类加载器加载

                    c = parent.loadClass(name, false);

                } else {

//如果不存在父类加载器，就检查是否是由启动类加载器加载的类，通过调用本地方法native Class findBootstrapClass(String name)

                    c = findBootstrapClass0(name);

                }

            } catch (ClassNotFoundException e) {

        // 如果父类加载器和启动类加载器都不能完成加载任务，才调用自身的加载功能

                c = findClass(name);

            }

        }

        if (resolve) {

            resolveClass(c);

        }

        return c;

    }