查看原文
其他

读Java虚拟机类加载引发的血案

点击上方 "程序员小乐"关注公众号, 星标或置顶一起成长

每天凌晨00点00分, 第一时间与你相约

每日英文

You will meet two kinds of people in life: ones who build you up and ones who tear you down. But in the end, you'll thank them both.

生命中你会遇到两种人:一种是鼓励你的人,一种是打击你的人,最终,这两者都要感谢。


每日掏心话

给生活一个微笑,给自己一个微笑,路还是要继续走。春有春的温暖,夏有夏的火热,秋有秋的收获,冬有冬的寒冷,学会享受生活!


来自花前月下的细说 | 责编:乐乐

链接:jianshu.com/u/ef2b368f8b29

程序员小乐(ID:study_tech)第 677 次推文   图片来自网络


往日回顾:iOS 13.2被频繁杀后台,微信官方出招了



   00 前言   


最近在看 Java 虚拟机类加载的知识点,结果让我发现了自己一个曾经一直纠结,又没彻底弄懂的类加载黑洞,从而引发下面一系列的测试血案。


相信面试过的你们也会见过类似下面测试的这几道题。不过,答案你真的理解了么?话不多说,直接 GKD。可惜我不是大佬,所以...哈哈哈 GKD 吧!下面就是测试过程种发现的一些疑惑点,赶紧记录一波...



   01 正文   


测试开始,先思考下下面代码输出什么:


class Singleton {

    public Singleton() {
        System.out.println("Singleton new instance");
    }

    static {
        System.out.println("Singleton static block");
    }

    {
        System.out.println("Singleton block !!!");
    }

}

public class NewTest {
    public static void main(String args[]){
        Singleton singleton = new Singleton();
    }
}


输出结果:


Singleton static block
Singleton block !!!
Singleton new instance


当然,大佬们应该都能知道答案...毕竟,新手入门级的野怪,谁都打得过。这个对我这小菜鸡也算还比较容易理解;加载连接过程,没有需要处理的 static。new Singleton() 直接开始类的初始化了,所以输出直接按照类的初始化顺序来就好了


类的初始化的执行顺序


没有父类的情况:


  1. 类的静态属性

  2. 类的静态代码块

  3. 类的非静态属性

  4. 类的非静态代码块

  5. 构造方法


有父类的情况:


  1. 父类的静态属性

  2. 父类的静态代码块

  3. 子类的静态属性

  4. 子类的静态代码块

  5. 父类的非静态属性

  6. 父类的非静态代码块

  7. 父类构造方法

  8. 子类非静态属性

  9. 子类非静态代码块

  10. 子类构造方法


这里有个小误区,是我自己的误区~~比如下面这个例子:


class ParentSingleton{

public static int value = 100;

public ParentSingleton(){
    System.out.println("ParentSingleton new instance");
}

static {
    System.out.println("ParentSingleton static block");
}

{
    System.out.println("ParentSingleton block !!! ");
}

}


当要初始化上面这个类的时候,会输出什么?


如果这时候,我们只看上面的初始化顺序,会觉得这样输出,根据顺序来嘛~


ParentSingleton static block
ParentSingleton block !!!
ParentSingleton new instance
???


OMG,错了,这里的顺序不是说,只要初始化,就要全部按照顺序一一执行...不是这样的。实际上只会输出:


ParentSingleton static block


如果有创建这个类的实例,比如 new ParentSingleton(),才会:


ParentSingleton block !!! 
ParentSingleton new instance


是的,这里的误区,我曾经一度搞错了...尴尬。那再看这个测试:


class Singleton {
private static Singleton singleton = new Singleton();

private Singleton() {
    System.out.println("Singleton new instance");
}

public static void forTest() {

}

static {
    System.out.println("Singleton static block");
}

{
    System.out.println("Singleton block !!! ");
}

}

public class TestSingleton {
public static void main(String args[]){
    Singleton.forTest();
}
}


看完资料的我,逐渐膨胀,毕竟100多斤的胖子,我想的输出应该是:


Singleton static block
Singleton block !!!
Singleton new instance


然后运行一看,懵逼了,结果是:


Singleton block !!! 
Singleton new instance
Singleton static block


咋回事啊,小老弟,结果乱套了...为什么不是先执行 static 代码块先了。认真想了一波,也不知道对不对,只能疯狂测试这样子...


经过一番测试,查看资料...最终...我觉得是这样子的。整个的流程详解应该是执行的第一步:Singleton.forTest();这时候,对Singleton类进行加载和连接,所以首先需要对它进行加载和连接操作。在连接-准备阶段,要讲给静态变量赋予默认初始值,这里还没到执行 forTest;初始值是 singleton = null。加载和连接完毕之后,再进行初始化工作:


private static Singleton singleton = new Singleton();


所以执行去到了 new Singleton();  这里因为 new 会引起 Singleton 的初始化。需要执行 Singleton构造函数里面的内容。但是又因为非static初始化块,这里面的代码在创建java对象实例时执行,而且在构造器之前!!!!就是这东西...所以输出应该是:


Singleton block !!! 
Singleton new instance


而根据类的初始化顺序,要执行 static 代码块,应该输出:


Singleton static block


完成初始化后。接下来就到真正调用 forTest 方法了,方法什么都不做,没输出。所以,总的答案就是:


Singleton block !!! 
Singleton new instance
Singleton static block


这里最大的原因就是,连接加载的时候,要给属性初始化,而这里的初始化又刚好是 创建java 实例,需要执行构造,执行构造的前面又必须先执行 {} 大括号非 static 块。而不是和第一个测试例子那样,static 属性不需要初始化,所以....


IG 永不加班,但我需要哇,继续测试吧...继续测试验证:


class Singleton {
private static Singleton singleton = new Singleton();

private Singleton() {
    System.out.println("Singleton new instance");
}

public static Singleton getSingleton() {
    return new Singleton();
}

static {
    System.out.println("Singleton static block");
}

{
    System.out.println("Singleton block !!! ");
}

}

public class TestSingleton {
public static void main(String args[]){
    Singleton singleton = Singleton.getSingleton();
}
}


输出结果如下所示。emm, 再次根据上面自己的理解,走一遍,应该是:


Singleton block !!! 
Singleton new instance
Singleton static block
Singleton block !!! 
Singleton new instance


这里后面第二次 new 为啥不引起第二次 类的初始化?? 因为一个类只能初始化一次啊!new 只是创建实例,不再初始化了。所以在调用 getSingleton 的时候,只创建实例就好了,而创建实例就是:


Singleton block !!! 
Singleton new instance


在同一个类加载器下面只能初始化类一次,如果已经初始化了就不必要初始化了。为什么只初始化一次呢?类加载的最终结果就是在堆中存有唯一一个Class对象,我们通过Class对象找到的那个唯一的。噢?运行看一手,丢,对了..还有存在 final 的时候,和存在父类的时候,下面慢慢再测试验证....继续测试:


class Singleton extends ParentSingleton {

public Singleton() {
    System.out.println("Singleton new instance");
}

static {
    System.out.println("Singleton static block");
}

{
    System.out.println("Singleton block !!! ");
}

}

class ParentSingleton{

public ParentSingleton(){
    System.out.println("ParentSingleton new instance");
}

static {
    System.out.println("ParentSingleton static block");
}

{
    System.out.println("ParentSingleton block !!! ");
}

}

public class TestSingleton {
public static void main(String args[]){
    Singleton singleton = new Singleton();
}
}


输出结果如下所示。这个,很明了,还是按照上面的类的初始化,有父类的情况按顺序调用,输出如下:


ParentSingleton static block
Singleton static block
ParentSingleton block !!! 
ParentSingleton new instance
Singleton block !!! 
Singleton new instance


继续测试如下所示。那个人,又来了...改成和上面没有父类一样的情况:


class Singleton extends ParentSingleton {
private static Singleton singleton = new Singleton();

private Singleton() {
    System.out.println("Singleton new instance");
}

public static Singleton getSingleton() {
    return singleton;
}

static {
    System.out.println("Singleton static block");
}

{
    System.out.println("Singleton block !!! ");
}

}

class ParentSingleton{

public ParentSingleton(){
    System.out.println("ParentSingleton new instance");
}

static {
    System.out.println("ParentSingleton static block");
}

{
    System.out.println("ParentSingleton block !!! ");
}

}

public class TestSingleton {
public static void main(String args[]){
    Singleton singleton = Singleton.getSingleton();
}
}


输出结果如下所示。这里,就开始懵了...有点。先看结果:


ParentSingleton static block
ParentSingleton block !!! 
ParentSingleton new instance
Singleton block !!! 
Singleton new instance
Singleton static block


其实,很容易看清了,现在,再走一遍流程吧!执行到 Singleton.getSingleton() 时,先加载 Singleton  ,这时因为 Singleton 有父类,需要需要加载父类先,加载父类 ParentSingleton,根据加载流程,在连接-准备阶段,要讲给静态变量赋予默认初始值,但父类没有 static 属性需要赋值初始化什么的,但是根据顺序,需要初始化static 代码块:


ParentSingleton static block


这时候回到子类的加载流程。根据连接-准备阶段,子类有需要处理的属性 private static Singleton singleton = new Singleton();赋值默认值先,singleton = null;然后初始化 singleton = new Singleton();根据上面的经验,这里是创建实例 ,并引起初始化,正常应该是:


Singleton block !!! 
Singleton new instance
Singleton static block


但是,重点来了 !!类实例创建过程:按照父子继承关系进行初始化,首先执行父类的初始化块部分。然后是父类的构造方法;再执行本类继承的子类的初始化块,最后是子类的构造方法,也就是:


ParentSingleton block !!! 
ParentSingleton new instance


同时子类的初始化,因为初始化子类它有父类,所以需要先初始化父类(但是这里因为父类已经初始化了,就不再初始化了)。所以结果是:


ParentSingleton static block
ParentSingleton block !!! 
ParentSingleton new instance
Singleton block !!! 
Singleton new instance
Singleton static block


最终测试如下所示:


class Singleton extends ParentSingleton {
private static Singleton singleton = new Singleton();

private Singleton() {
    System.out.println("Singleton new instance");
}

public static Singleton getSingleton() {
    return singleton;
}

static {
    System.out.println("Singleton static block");
}

{
    System.out.println("Singleton block !!! ");
}

}

class ParentSingleton{

private static ParentSingleton parentSingleton = new ParentSingleton();   

public ParentSingleton(){

    System.out.println("ParentSingleton new instance");
}

static {
    System.out.println("ParentSingleton static block");
}

{
    System.out.println("ParentSingleton block !!! ");
}

}

public class TestSingleton {
public static void main(String args[]){
    Singleton singleton = Singleton.getSingleton();
}
}


测试结果如下所示:


ParentSingleton block !!! 
ParentSingleton new instance
ParentSingleton static block
ParentSingleton block !!! 
ParentSingleton new instance
Singleton block !!! 
Singleton new instance
Singleton static block


加载一个类时,先加载父类。按照先加载,创建实例,初始化,这个顺序就发现很通顺的写出答案了。哈哈哈哈哈,终于清楚了。所以一切的一切,都是创建实例这个东西。搞得我头晕。


部分特殊不引起类初始化记录,先记录下吧。


  1. 通过子类引用父类的静态字段,不会导致子类初始化,对于静态字段,只有直接定义这个字段的类才会被初始化

  2. 通过数组定义来引用类,不会触发此类的初始化

  3. 常量在编译阶段会存入调用类的常量池中,本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化

  4. public static final int x =6/3;  能够在编译时期确定的,叫做编译常量,不会引起类的初始化!!!

  5. public static final int x =new Random().nextInt(100); 运行时才能确定下来的,叫做运行时常量,运行常量会引起类的初始化!!!


在虚拟机规范中使用了一个很强烈的限定语:“有且仅有”,这5种场景中的行为称为对类进行主动引用。除此之外,所有引用类的方式都不会触发初始化,称为被动引用。


5种必须初始化的场景如下


1.    遇到new、getstatic、putstatic或invokestatic这4条字节码指令时,如果类没有初始化,则需要先触发其初始化


这4条指令对应的的常见场景分别是:使用new关键字实例化对象、读取或设置一个类的静态字段(被final修饰、已在编译期把结果放入常量池的静态字段除外)的时候,以及调用一个类的静态方法的时候。


注:静态内容是跟类关联的而不是类的对象。


2.    使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没有进行过初始化,则需要先触发其初始化。


注:反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法


对于任意一个对象,都能够调用它的任意一个方法和属性


这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制,这相对好理解为什么需要初始化类。


3.    当初始化一个类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化。


注:子类执行构造函数前需先执行父类构造函数


4.    当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的那个类),虚拟机会先初始化这个主类。


注:main方法是程序的执行入口


5.    当使用JDK1.7的动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个方法句柄所对应的类没有进行过初始化。则需要先触发其初始化。


注:JDK1.7的一种新增的反射机制,都是对类的一种动态操作


这回,以后看代码的时候,就不会再被这些执行加载顺序弄混了,对优化代码可能还是有帮助的吧。


再不说,也能再让我看到这些测试题,或者问我加载的过程,怎么也能处理回答个7788了吧。


可能其中个人理解有部分纰漏,还请大佬们指出~~蟹蟹鸭!


欢迎在留言区留下你的观点,一起讨论提高。如果今天的文章让你有新的启发,学习能力的提升上有新的认识,欢迎转发分享给更多人。

欢迎各位读者加入程序员小乐技术群,在公众号后台回复“加群”或者“学习”即可。

猜你还想看


阿里、腾讯、百度、华为、京东最新面试题汇集

分布式缓存技术Redis系列(一)Redis简介以及Linux上的安装

优化你的SpringBoot,看这篇文章就对了!

Java 操作Word表格——创建嵌套表格、添加/复制表格行或列、设置表格是否禁止跨页断行


关注微信公众号「程序员小乐」,收看更多精彩内容
嘿,你在看吗?

    您可能也对以下帖子感兴趣

    文章有问题?点此查看未经处理的缓存