并发线程-volatile关键字
1、结论
volatile具有可见性和防止指令重排的能力，但是在某些场景下不能保证线程安全（无法替代synchronized关键字）
2、原因简析
1、线程安全问题中有三个概念：原子性（Atomicity）、可见性（Visibility）、有序性（Ordering）。
2、synchronized关键字可以保证原子性、可见性和有序性；volatile只能保证可见性和有序性（有序性体现在 防止指令重排 上）。
3、使用volatile修饰的（多线程共享的）变量进行的是原子的修改操作时，这时volatile可以保证线程安全；除此之外，单一地使用volatile不保证线程安全。
4、volatile会对总线（主存）加上LOCK前缀指令（观察汇编源码得知），LOCK不是内存屏障，但是完成的事情是类似内存屏障（也叫内存栅栏）的功能。LOCK可以理解成是CPU一级的锁，加上LOCK后，其他CPU对该内存地址的原子的读写请求都会被阻塞，直到锁释放。（《码出高效Java开发手册》P232中描述使用了volatile后“...任何对此变量的操作都会在内存中进行，不会产生副本”，笔者认为描述有问题）
5、单一地使用synchronized（来保证线程安全）会有一定的效能损耗，可以用volatile搭配使用synchronized减少（因为要保证线程安全带来的）效能损耗，也可以搭配CAS（比如自旋锁运用了CAS -- Compare-And-Swap）。
3、背景
计算机在对内存进行操作时，会存在主内存（有些地方叫物理内存）和高速缓存的概念。主存中的变量值对所有线程可见，高速缓存是线程私有的--对其他线程不可见的。CPU对内存进行操作的时候，单个线程会从主存（总线）中读取目标内存地址中的数据，copy到高速缓存（作为副本），后续的一系列操作都是基于这个“副本”，操作完后，将副本的值同步回主存。
内存栅栏实现了 可见性 和 防止指令重排 的效果
内存栅栏/内存屏障
4、代码验证
4.1、这是一段线程不安全的代码
public class Test {
public static volatile int inc = 0;
public static void increase() throws InterruptedException {
inc++;
}
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i < 5; i++){
try {
increase();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----A过程---" + Test.inc);
}
}
});
Thread thread2 = new Thread(new Runnable(){
@Override
public void run() {
for (int i = 0; i < 5; i++){
try {
increase();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----B过程---" + Test.inc);
}
}
});
thread1.start();
thread2.start();
Thread.sleep(2000);
System.out.println("--终态--" + inc);
}
}
4.2、对#4.1代码的优化
·#4.1的代码不能复现出问题，猜测可能是机器的CPU性能较好。所以优化了下代码，如下
public class Test {
public static volatile int inc = 0;
public static void increase() throws InterruptedException {
Thread.sleep(1);
inc ++;
}
public static void main(String[] args) throws InterruptedException {
for (int k=0;k<10;k++){
new Thread(new Runnable(){
@Override
public void run() {
for (int i=0 ; i < 500; i++){
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2);
increase();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----A过程---" + inc);
}
}).start();
}
}
}).start();
new Thread(new Runnable(){
@Override
public void run() {
for (int i=0 ; i < 500; i++){
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2);
increase();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("----B过程---" + inc);
}
}).start();
}
}
}).start();
}
Thread.sleep(5000);
System.out.println("--终态--" + inc);
}
}
4.3、#4.2的运行结果
预期结果是10,000，实际运行结果<10,000
4.4、原因
因为#4.1和#4.2的模型一样，#4.1的逻辑更简单，故以#4.1为例讲
4.4.1、首先，问题出在这一行
inc++
4.4.2、其次，inc++非原子操作
inc++ 即 inc = inc + 1
4.4.3、出现异常（结果不合预期）的情况
step-1
step-2
step-3
step-4
step-5
4.5、反思
从结果看来，在这个场景中，volatile没有发挥任何作用嘛？
我们去掉#4.2代码中的volatile关键字，发现结果也是少于10,000
没有volatile修饰inc变量的情况
我认为，volatile还是发挥作用的（只是没有它没有让结果达到预期），举个例子
去掉volatile后，step-4的线程B不是无效掉前两步的操作，而是将自己的副本（inc=2）更新到主存中，这时主存中的inc值又被更新了一次（2 -> 2）;
假设在线程竞争中，线程B获得的CPU时间片轮远少于线程A时，当线程A对inc更新过好几轮了后（假设此时主存中的inc=4）,线程B仍然对主存更新为2。这时主存中的inc值经历了几个阶段
主存中inc的几个阶段
4.6、比较明确地体现volatile的可见性作用的例子
1、状态标记量
volatile boolean flag = false;
while(!flag){
doSomething();
}
public void setFlag() {
flag = true;
}
2、双重检测锁
class Singleton{
private volatile static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if(instance==null) {
synchronized (Singleton.class) {
if(instance==null)
instance = new Singleton();
}
}
return instance;
}
}
5、volatile适用的场景
1）对变量的写操作不依赖于当前值
2）该变量没有包含在具有其他变量的不变式中
针对这两点约束，个人还不是很理解，具体参考# volatile的适用场景
6、参考来源
1、 Java并发编程：volatile关键字解析
2、 volatile 和 内存屏障
3、《码出高效Java开发手册》
