java中类的加载和线程使用所导致的变量值异常情况

首先我们来看一段代码：

//这个抽象类从它的构造方法中分别先后调用first和second方法
public abstract class TestParent{

    public TestParent(){
        first();
        second();
    }

    abstract void first();//首先调用
    abstract void second();//其次调用
}

//TestThread继承上面的抽象类，并声明了一个boolean类型常量，初始化赋值为false
public class TestThread extends TestParent{
    
    private boolean b = false;//关键量

    TestThread(){
        super();//这里调用父类的构造方法，而后父类的构造方法先后调用first、second
    }

    @Override
    public void first(){
        b = true;//在first方法中将b的值修改为true
        System.out.println("first方法中：此时b的值为->"+b);
    }

    @Override
    public void second(){
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("子线程中：此时b的值为->"+b);
            }
        }).start();
    }

}

现在根据上面的代码，大家能否推测出如果我new TestThread()会输出什么吗？
 

//刚开始我认为这段代码会输出:
first方法中：此时b的值为->true
子线程中：此时b的值为->true
//而实际结果是:
first方法中：此时b的值为->true
子线程中：此时b的值为->false

wtf！！？为什么会这样呢？明明在first方法中已经将b的值修改为true啊！而且根据日志输出，肯定是先运行了first方法，然后在运行second方法。为什么在second中依然是false呢？

为了一探究竟，我又在second方法中加了一行输出：

    public void second(){
        //在线程启动前再加一行输出
        System.out.println("second方法中：此时b的值为->"+b);
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("子线程中：此时b的值为->"+b);
            }
        }).start();
    }

    //然而其输出结果为：
    first方法中：此时b的值为->true
    second方法中：此时b的值为->true
    子线程中：此时b的值为->false

从输出结果来看，问题应该是出在了new Thread()上面了。。。second方法中的b值还为true，而线程中的b值已经是false了。

而b的赋值只有两个地方，一个是first中将其赋值为true，另一个是初始化时的默认值false。显然在second中的这个Thread拿到的是b的初始化默认值。那么为什么会这样呢？明明在这个Thread被new出来的时候，b的值已经改变了。Thread是从哪里拿到的这个值呢？

带着这个问题，我又修改了代码，假设我们不通过父类的构造方法来调用first和second这两个方法，而是直接调用会发生什么呢？

public class TestThread extends TestParent{

    private boolean b = false;

    TestThread(){
        // super(); 不再调用父类的构造，直接调用first和second
        first();
        second();
    }

    @Override
    public void first(){
        b = true;
        System.out.println("first方法中：此时b的值为->"+b);
    }

    @Override
    public void second(){
        System.out.println("second方法中：此时b的值为->"+b);
        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("子线程中：此时b的值为->"+b);
            }
        }).start();
    }
}

修改之后的运行结果：

first方法中：此时b的值为->true
second方法中：此时b的值为->true
first方法中：此时b的值为->true
second方法中：此时b的值为->true
子线程中：此时b的值为->true
子线程中：此时b的值为->true

哇哦。。。结果刷新了我对java的认识。。。原来即时我们不通过super()关键字，父类的构造方法还是会被调用。进而导致了first和second方法都被调用了两次。

但是这次b的结果是没有问题的，统一为true了。。。为什么呢？按照我之前的猜测，如果是Thread的问题，那么这次运行结果应该也是要让b值为false呀。。。由此可见，Thread只是暴露了这个问题，但并不是问题的本质。。。

那么本质是什么呢。。。为什么不通过super方法也会调用父类的构造方法呢？而且不通过super方法之后，Thread中的值也正常了。这是为什么呢？？？

为了再探究竟。。。我又双修改了代码：

    public class TestThread extends TestParent{
        //。。。省略部分代码
        TestThread(){
            //这里增加输出
            System.out.println("子类的构造方法");
            // first();
            // second();
        }
        //。。。省略部分代码
    }

    public abstract class TestParent{

        public TestParent(){
            System.out.println("父类的构造方法");
            first();
            second();
        }
        //。。。省略部分代码
    }

修改之后的运行情况：

父类的构造方法
first方法中：此时b的值为->true
second方法中：此时b的值为->true
子类的构造方法
子线程中：此时b的值为->false

根据输出的日志。。。我们来进行一下java类生成原理的分(xia)析(cai)：

首先必须先生成父类，现有父类才有子类

随后会先运行父类构造方法中调用的方法（不管是抽象方法，还是普通方法）

以上都做完之后，子类才会开始被生成

OK这套理论非常完美（沾沾自喜）。。。但是！！！这仍然不能解释为什么Thread中输出的b值为false。

没错这确实没法解释，因为这还涉及Thread对象的特殊性。

Thread是java中的线程类，用于异步处理数据。因为它是异步的，所以它并不能直接在java虚拟机中对非异步变量进行修改。

在java中每一个线程都会被分配一个独立内存空间，这个空间中的变量值是java虚拟机中其它变量值的副本。当一个线程执行完毕之后，会将自己独立空间中的副本覆盖到java虚拟机中对应的变量中去。

这就是java中线程的工作原理，也正是因为这样。当多个线程同时对一个值进行操作时，经常会出现线程不安全的情况。其主要原因就是这样，多个线程对应了多个变量副本，每个线程各自为政将自己处理好的副本覆盖到对应的变量中。这样就引出了volatile关键字的作用，下次再开一篇博客来讲。。。

回到我们刚刚的代码，second方法中new 了一个Thread对象，注意此时的Thread已经初始化完成，并且调用了start方法。这意味着此时它已经拿到b值的副本。（但它没有马上运行，因为线程的运行需要由虚拟机调配）

注意哦，代码运行到这里TestThread对象（子类）还没被加载出来呢。。。所以Thread拿到的副本只能是b的默认值false。

当然有小伙伴会问了，那first方法中修改的b值是哪来的呢？子类还没被加载，为什么就可以直接调用子类的常量了？

这是因为java中类的加载过程：
        1、加载class文件
        2、堆中开辟空间
        3、变量的默认初始化
        4、变量的显示初始化
        5、构造代码块初始化
        6、构造方法初始化

        7、如果存在继承的情况，会先加载父类的数据（包括变量和方法），再加载子类的数据（包括变量和方法）

于是乎。。。由于这其中的种种原因。。。导致了我们看到输出的值非常懵逼！！！（java的运行原理是基本功呀）