【面试题】java类加载机制探索

【面试题】java类加载机制探索

参考文章

参考文章二

面试题一：

class SingleTon {
	private static SingleTon singleTon = new SingleTon();
	public static int count1;
	public static int count2;

	private SingleTon() {
		count1++;
		count2++;
	}

	public static SingleTon getInstance() {
		return singleTon;
	}
}

public class Test {
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.getInstance();
		System.out.println("count1=" + singleTon.count1);
		System.out.println("count2=" + singleTon.count2);
	}
}

经常看到这么一句话：这是一个单例模式，通过classLoader机制避免多线程同步的问题。

先看看控制台打印结果：

count1=1
count2=1

似乎是一个显而易见的答案。OK，问题刚刚开始。

问题一、如何通过classLoader机制避免多线程同步的问题？

答：多个线程同时调用getInstance()方法时，就本例来说，如果不存在SingleTon实例对象，则会触发类的初始化。已经存在类初始化，则直接会去调用。

jvm有严格的规定（五种情况）：

1.遇到new，getstatic，putstatic，invokestatic这4条字节码指令时，假如类还没进行初始化，
则马上对其进行初始化工作。
其实就是3种情况：用new实例化一个类时、读取或者设置类的静态字段时（不包括被final修饰的静态字段，
因为他们已经被塞进常量池了）、以及执行静态方法的时候。

2.使用java.lang.reflect.*的方法对类进行反射调用的时候，
如果类还没有进行过初始化，马上对其进行。

3.初始化一个类的时候，如果他的父亲还没有被初始化，则先去初始化其父亲。

4.当jvm启动时，用户需要指定一个要执行的主类（包含static void main(String[] args)的那个类），
则jvm会先去初始化这个类。

5.用Class.forName(String className);来加载类的时候，也会执行初始化动作。
注意:ClassLoader的loadClass(String className);方法只会加载并编译某类，并不会对其执行初始化。

面试题二：

class SingleTon {
	private static SingleTon singleTon = new SingleTon();
	public static int count1;
	public static int count2 = 0;

	private SingleTon() {
		count1++;
		count2++;
	}

	public static SingleTon getInstance() {
		return singleTon;
	}
}

public class Test {
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.getInstance();
		System.out.println("count1=" + singleTon.count1);
		System.out.println("count2=" + singleTon.count2);
	}
}

有人问我是不是把面试题又抄了一遍？再仔细看看。

对，我只是对count2做了一个初始化。

public static int count2 = 0;

可能你认为的结果是这样的：

count1=1
count2=1

然而结果是：

count1=1
count2=0

不过是一个对count2的初始化，为什么结果居然变了？
答案：因为类初始化的顺序为，先加载 static，再构造器。

初始化也就是一个赋值的过程。

例如，本例：

private static SingleTon singleTon = new SingleTon();
	public static int count1;
	public static int count2=0 ;

先第一行初始化，调用new SingleTon()对count1，count2赋值为count1=1，count2=1。

第二行没有赋值，所以count1=1不变。

第三行赋值count2为0。

故，答案为count1 =1，count2 = 0。好吧，全部都是套路。

面试题三、此处有个疑问：虽然能够答出上面这个答案的应该基本都不存在这个疑问。

先初始化new SingleTon()的时候count1 ，count2什么时候分配内存空间的？

先推断一番，肯定不是在初始化的时候才分配内存空间的，因为先执行构造方法的时候可以设置count值。这个时候肯定已经分配好了。OK，不推测了。

直接回到主题：

先摆理论：

类从被加载到虚拟机内存中开始，直到卸载出内存为止，
它的整个生命周期包括了： 加载、验证、准备、解析、初始化、使用和卸载 这7个阶段。
其中， 验证、准备和解析这三个部分统称为连接（linking） 。 

知道理论后：

1）加载：在java堆中，创建class类对象。

2）准备：准备阶段是为类的静态变量分配内存并将其初始化为默认值，这些内存都将在方法区中进行分配。比如本例，将分配count1，count2内存，并赋默认值0，0。（int类型默认值）

3）初始化：先static，再构造器。则按照static在方法内的顺序。

OK，基本上问题回答完了。也知道了count1，count2的分配内存在准备阶段，而初始化的时候早就有了这两个内存空间。

面试题四、父类，子类加载顺序。

最开始说初始化一直没提继承父类的类的初始化顺序，由于参杂在一起看起来就比较复杂了。

现在举个例子：

父类A:

public class A{
	static{
		System.out.println("父类-静态代码块");
	}
	{
		System.out.println("父类-非静态代码块");
	}
	public A(){
		System.out.println("父类-构造方法");
	}
}

子类B:

public class B extends A{
	static{
		System.out.println("子类-静态代码块");
	}
	{
		System.out.println("子类-非静态代码块");
	}
	public B(){
		System.out.println("子类-构造方法");
	}
}

测试一下：

public class Test{
	public static void main(String[] args) {
		B b = new B();
	}
}

看看效果:

父类-静态代码块
子类-静态代码块
父类-非静态代码块
父类-构造方法
子类-非静态代码块
子类-构造方法

看到这，就知道初始化子类会先初始化父类。顺序为 父类静态——》子类静态——》父类非静态代码块——》父类构造方法——》子类非静态代码块——》子类构造方法。

原因在这：

3.初始化一个类的时候，如果他的父亲还没有被初始化，则先去初始化其父亲。

最后留一个思考题：

public class Main {
 public static void main(String[] args){
 System.out.println("我是main方法，我输出Super的类变量i："+Sub.i);
 Sub sub = new Sub();
 }
}
class Super{
 {
 System.out.println("我是Super成员块");
 }
 public Super(){
 System.out.println("我是Super构造方法");
 }
 {
 int j = 123;
 System.out.println("我是Super成员块中的变量j："+j);
 }
 static{
 System.out.println("我是Super静态块");
 i = 123;
 }
 protected static int i = 1;
}
class Sub extends Super{
 static{
 System.out.println("我是Sub静态块");
 }
 public Sub(){
 System.out.println("我是Sub构造方法");
 }
 {
 System.out.println("我是Sub成员块");
 }
}