Java多线程学习（三）volatile关键字_线程可以把变量保存本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_25080241/article/details/102795849

简介

Java中的“volatile关键字”关键字：

Java的内存模型实现总是从主存（即共享内存）读取变量，是不需要进行特别的注意的。而在当前的 Java 内存模型下，线程可以把变量保存本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。
数据的不一致，要解决这个问题，就需要把变量声明为 volatile，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。

volatile关键字的可见性

volatile 修饰的成员变量在每次被线程访问时，都强迫从主存（共享内存）中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主存（共享内存）。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值，这样也就保证了同步数据的可见性。

public class LockTest extends Thread {
    private boolean isRunning = true;
    int m;
    public boolean isRunning() {
        return isRunning;
    }
    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    @Override
    public void run() {
        System.out.println("进入run了");
        int a = 1;
        while (isRunning == true) {
            m = a++;
        }
        System.out.println(m);
        System.out.println("线程被停止了！");
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
        LockTest lockTest = new LockTest();
        lockTest.start();
        Thread.sleep(1000);
        lockTest.setRunning(false);
}

结果：

死循环

原因：
RunThread类中的isRunning变量没有加上volatile关键字时，运行以上代码会出现死循环，这是因为isRunning变量虽然被修改但是没有被写到主存中，这也就导致该线程在本地内存中的值一直为true，这样就导致了死循环的产生。
解决办法：
isRunning变量前加上volatile关键字即可。

“强调” 假如你把while循环代码里加上任意一个输出语句或者sleep方法你会发现死循环也会停止，不管isRunning变量是否被加上了上volatile关键字。

public class LockTest extends Thread {
    private boolean isRunning = true;
    int m;
    public boolean isRunning() {
        return isRunning;
    }
    public void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }
    @Override
    public void run() {
        System.out.println("进入run了");
        int a = 1;
        while (isRunning == true) {
            m = a++;
            System.out.println(m);
        }
        System.out.println(m);
        System.out.println("线程被停止了！");
    }
}

public static void main(String[] args) throws ExecutionException, InterruptedException {
      LockTest lockTest = new LockTest();
      lockTest.start();
      Thread.sleep(1000);
      lockTest.setRunning(false);
}

结果：

进入run了
1
2
...
...
线程被停止了！

原因：
JVM会尽力保证内存的可见性，即便这个变量没有加同步关键字。换句话说，只要CPU有时间，JVM会尽力去保证变量值的更新。这种与volatile关键字的不同在于，volatile关键字会强制的保证线程的可见性。而不加这个关键字，JVM也会尽力去保证可见性，但是如果CPU一直有其他的事情在处理，它也没办法。最开始的代码，一直处于死循环中，CPU处于一直占用的状态，这个时候CPU没有时间，JVM也不能强制要求CPU分点时间去取最新的变量值。而加了输出或者sleep语句之后，CPU就有可能有时间去保证内存的可见性，于是while循环可以被终止。

volatile关键字能保证原子性吗？

volatile无法保证对变量原子性的

public class MyThread extends Thread {
            volatile public static int count;
            private static void addCount() {
                for (int i = 0; i < 100; i++) {
                    count = i;
                }
                System.out.println("count=" + count);
            }
            @Override
            public void run() {
                addCount();
            }
}

public class Run {
            public static void main(String[] args) {
                MyThread[] mythreadArray = new MyThread[100];
                for (int i = 0; i < 100; i++) {
                    mythreadArray[i] = new MyThread();
                }
                for (int i = 0; i < 100; i++) {
                    mythreadArray[i].start();
                }
            }
        }

运行结果：
上面的“count=i;”是一个原子操作，但是运行结果大部分都是正确结果99，但是也有部分不是99的结果。
解决办法：
使用synchronized关键字加锁。（这只是一种方法，Lock和AtomicInteger原子类都可以）

synchronized关键字和volatile关键字比较

volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用synchronized关键字还是更多一些。
多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞
volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。
volatile关键字用于解决变量在多个线程之间的可见性，而ynchronized关键字解决的是多个线程之间访问资源的同步性。