Java 关键字 volatile

---

volatile

• volatile（易失）是一个"变量修饰符"，它只能修饰"成员变量"，它能强制线程每次从主内存获取值，并能保证此变量不会被编译器优化；
• volatile 能解决变量的可见性、有序性；
• volatile 不能解决变量的原子性；

---

1. 解决可见性

• 当变量被修饰为 volatile 时，会迫使线程每次使用此变量，都会去主内存获取，保证其可见性；

class MyThread extends Thread {
    public static volatile int a = 0;//增加volatile关键字

    @Override
    public void run() {
        System.out.println("线程启动，休息2秒...");
        try {
            Thread.sleep(1000 * 2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("将a的值改为1");
        a = 1;
        System.out.println("线程结束...");
    }
}

public class Test {
    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");
            }
        }
    }
}
/*
输出
主线程读到了a = 1
/

---

2. 解决有序性

• 当变量被修饰为 volatile 时，会禁止代码重排；

---

3. 不能解决原子性

• 加入volatile关键字并不能解决原子性，如下例：

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

    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            //线程1：取出a的值a=0(被暂停)
            a++;
            //写回
        }
        System.out.println("修改完毕！");
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //1.启动两个线程
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.start();
        t2.start();
        Thread.sleep(1000);
        System.out.println("获取a最终值：" + MyThread.a);//最终结果仍然不正确。
    }
}
/*
输出
修改完毕！
修改完毕！
获取a最终值：14106
 */

• 可见，volatile 关键字只能解决"变量"的可见性、有序性问题，并不能解决原子性问题；