Java并发编程 之volatile关键字详解

volatile 是 Java 虚拟机提供的轻量级的同步机制

JMM内存模型三大规范特性： 原子性、可见性、有序性。
volatile： 轻量级的同步机制，解决可见性、有序性，不保证原子性。
保证可见性： 将其他线程的工作内存中的值失效。
保证有序性： 禁止指令重排。

上面的代码共享变量如果不加 volatile 的话，可能会导致第二个线程一直在死循环，因为data值被第一个线程修改后，第二个线程读取data是从自己的工作内存中读取的，自己的工作内存中的data值是0，如果加了volatile，data值具有可见性，在被第一个线程修改后，会将其他线程的工作内存的data值失效，其他线程使用data值会从主内存读取。

在多线程开发中，多个线程如果需要同时使用一个共享变量，这个共享变量需要加volatile，保证可见性。

public class Kafka{
	// running 是多个线程的共享变量
	private volatile boolean running = true;
	public void shutdown(){
		running = false;
	}
	public static void main(){
		Kafka kafka = new Kafka();
		// 因为running变量加了volatile，只要其他线程修改了running的值，当前线程内存中的running会失效，然后从主内存中读取
		while(kafka.running){
			Thread.sleep(1000);
		}
	}	
}

JMM概念

JMM（Java内存模型 Java Memory Model）： 程序中各个变量的访问方式。

JMM理解：
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方成为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有共享变量都存储在主内存，主内存是共享内存区域，所有线程都可访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成再将变量写回主内存， 不能直接操作主内存中的变量，各个线程中的工作内存储存着主内存中的变量副本拷贝，因此不同的线程无法访问对方的工作内存，线程间的通讯（传值） 必须通过主内存来完成。
read、load、use、assign、store、write

JMM三大规范特性

1. 可见性： 各个线程对主内存中共享变量的操作，都是各个线程读取到自己的工作内存操作后，再写回主内存。
   可能存在一个线程A读取了主内存共享变量X，并修改，但还未及时写回到主内存中，另外一个线程B读取了主内存中的共享变量X进行操作，但此时线程A在工作内存中修改的值X，对线程B是不可见。
   这种工作内存与主内存同步延迟的现象造成了可见性问题。
2. 原子性： k = k++ 和 k = ++k 语句的执行过程有多个操作组成，原子性就是保证多个操作必须是独立执行，不可分割的，必须执行完，其他线程才能执行。
3. 有序性： 编译器和指令器，有的时候为了提高代码执行效率，会将指令重排序。
   下面的代码，编译器在重排序之后，让flag = true先执行了，会导致线程2直接跳过while等待，执行下面的代码，结果prepare()方法还没执行，资源还没准备好呢，此时就会导致代码逻辑出现异常。
   

保证可见性

可见性问题主要指一个线程修改了共享变量值，而另一个线程却看不到。
引起可见性问题的主要原因是每个线程拥有自己的一个高速缓存区——线程工作内存。

public class VolatileDemo {
    int number = 0;
    public void add() {
        number++;
    }
    public static void main(String[] args) {
        VolatileDemo volatileDemo = new VolatileDemo();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\tstart");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
            }
            volatileDemo.add();
            System.out.println(Thread.currentThread().getName() + "\t" + volatileDemo.number);
        }, "AAA").start();
        while (volatileDemo.number == 0) {
        }
        System.out.println(Thread.currentThread().getName() + "\tend\t" + volatileDemo.number);
    }
}

未在共享变量上添加volatile关键字，程序不会执行结束，因为线程AAA修改的共享变量对于主线程是不可见的。
如果添加volatile关键字，在线程AAA修改共享变量后，会使其他线程的共享变量失效，会从主内存中读取，所以会正常结束。

禁止指令重排

在并发环境下的单例实现方式，通常可以采用双重检查加锁(DCL)的方式来实现。

public class Singleton {
    public static volatile Singleton singleton;   
    private Singleton() {};
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (singleton) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

分析一下为什么要在变量singleton之间加上volatile关键字。

要理解这个问题，先要了解对象的构造过程，实例化一个对象其实可以分为三个步骤：
1、分配内存空间。
2、初始化对象。
3、将内存空间的地址赋值给对应的引用。

但是由于操作系统可以对指令进行重排序，所以上面的过程也可能会变成如下过程：
1、分配内存空间。
2、将内存空间的地址赋值给对应的引用。
3、初始化对象

如果是这个流程，多线程环境下就可能将一个未初始化的对象引用暴露出来，从而导致不可预料的结果。因此，为了防止这个过程的重排序，我们需要将变量设置为volatile类型的变量。

i++ 和 ++i 原理解析

i++ 底层执行过程：

public class Test {
    public static void main(String[] args) {
        int k = 10;
        k = k++;
    }
}

public class com.boot.Test {
  public com.boot.Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        10 // 将参数10压入栈
       2: istore_1		   // 栈中弹出一个数(10)，赋值给局部变量_1(_1表示赋值给第一个局部变量，即k)
       3: iload_1          // 将局部变量_1(_1表示第一个局部变量，即k)的值入栈，此时栈顶的值为10
       // 指令iinc对给定的局部变量做自增操作
       // 1,1表示对第一个局部变量k进行累加1操作，意味着k变为了11
       4: iinc          1, 1 
        // 栈顶弹出一个数：也就是10，赋值给第一个局部变量_1，意味着k的值又变回10了。(_1表示赋值给第一个局部变量，即k)
       7: istore_1
       8: return
}

通过指令分析，值在自增之前压入栈了，并且自增后，并没有压入栈，所以最后在栈顶弹出值赋值给第一个局部变量，是自增之前的值。

++i 底层执行过程：

public class Test {
    public static void main(String[] args) {
        int k = 10;
        k = ++k;
    }
}

public class com.boot.Test {
  public com.boot.Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: bipush        10 // 将参数10压入栈
       2: istore_1         // 栈中弹出一个数(10)，赋值给局部变量_1(_1表示赋值给第一个局部变量，即k)
       // 指令iinc对给定的局部变量做自增操作
       // 1,1表示对第一个局部变量k进行累加1操作，意味着k变为了11
       3: iinc          1, 1
        // 将局部变量_1(_1表示第一个局部变量，即k)的值入栈，此时栈顶的值为11
       6: iload_1
        // 栈顶弹出一个数：也就是11，赋值给第一个局部变量_1。(_1表示赋值给第一个局部变量，即k)
       7: istore_1
       8: return
}

通过指令分析，值在自增之后压入栈了，所以最后在栈顶弹出值赋值给第一个局部变量，是自增之后的值。

从上面的分析可知，k = k++ 和 k = ++k 语句的执行过程有多个操作组成，不是原子操作，因此不是线程安全的。

Java并发编程：volatile关键字解析