实验室学姐问我可见性的细节？让我不知所措【多线程中的可见性原理初探】

        之前也只是知道有可见性这么回事，但是原理不算很明白！今天把多线程的可见性原理梳理一下，原理弄懂，而非死记硬背！
        先看多线程例子：

public class Demo {
    public static void main(String[] args) {
        //1. 启动线程
        MyThread t = new MyThread();
        t.start();

        //2.主线程继续
        while (true){
            if (MyThread.a ==1){
                System.out.println("主线程读到了a=1");
                break;
            }
        }

    }
}

class MyThread extends Thread {
    public static int a = 0;

    @Override
    public void run() {
        System.out.println("线程启动，休息2s...");
        try {
            Thread.sleep(1000*2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("将a的值改为1");
        a = 1;
        System.out.println("线程结束");
    }
}

        这里启动了一个MyThread线程，并在主线程里面不断的去判断该成员变量a的值是否进行了修改，而实际情况是MyThread线程对值修改之后，主线程中并没有拿到这个最新的值而跳出while循环，那么这又是为啥呢？

        当一个线程启动后，会单独建立一个栈供使用，那么这里就有主线程和新线程两个栈，启动线程后，栈内调用的成员变量、成员方法这些都是从同一个方法区中获取的，比如这里的MyThread.class静态区，拿到的都是方法区中的副本存到自己线程的栈内存当中，所以这个值就应该是线程启动当时的副本状态！只要不修改这个副本文件，就会一直使用这个副本，也不会重新去方法区拿。
当修改了副本后，他会立刻同步到方法区中，比如这里的新线程修改使得a=1，那么就会立刻去改方法区中MyThread.class静态区a的值为1，那么这个新线程今后用的值都是这个修改后的副本了，但是对于主线程，它拿到的一直是a修改之前的最开始的那个副本文件，所以对于主线程来说a=0。

总结1： 每个线程去使用共享内容时候，是把共享的内容复制一份副本到自己的栈内存
总结2： 副本中的值发生改变时，立刻同步到方法区中
总结3： 如果当前线程没有重新从方法区中拷贝副本，那么使用的资源还是上一次拿到的副本文件

        那么，如何让主线程也拿到最新修改的方法区呢？也就是说如何再次获取一个最新的副本呢？有以下几个方法：

1. 让主线程sleep一下，那么线程休眠后再启动则会重新复制资源副本到主线程栈内存中。
2. 给成员变量a设置volatile修饰符，保证其可见性！
3. 使用同步代码块synchronized：只要遇到同步，那么线程也会重新去方法区拿最新的资源副本

方法一：让主线程sleep而重新获取资源副本到栈内存当中

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        //1. 启动线程
        MyThread t = new MyThread();
        t.start();

        //2.主线程继续
        while (true){
            Thread.sleep(1);
            if (MyThread.a ==1){
                System.out.println("主线程读到了a=1");
                break;
            }
        }

    }
}

class MyThread extends Thread {
    public static int a = 0;

    @Override
    public void run() {
        System.out.println("线程启动，休息2s...");
        try {
            Thread.sleep(1000*2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("将a的值改为1");
        a = 1;
        System.out.println("线程结束");
    }
}

方法二：使用volatile，直接给a变量加即可：

public static volatile int a = 0;

方法三：使用同步代码块 synchronized，这里随便对什么加锁都行，都会重新向方法区请求最新资源

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        //1. 启动线程
        MyThread t = new MyThread();
        t.start();

        //2.主线程继续
        while (true){
//            Thread.sleep(1);
            synchronized (Demo.class) {}
            if (MyThread.a ==1){
                System.out.println("主线程读到了a=1");
                break;
            }
        }

    }
}

class MyThread extends Thread {
    public static   int a = 0;

    @Override
    public void run() {
        System.out.println("线程启动，休息2s...");
        try {
            Thread.sleep(1000*2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("将a的值改为1");
        a = 1;
        System.out.println("线程结束");
    }
}