1.并发编程的三个重要特性

并发编程有三个至关重要的特性，分别是原子性、有序性和可见性

1.1 原子性

所谓原子性是指在一次的操作或者多次操作中，要么所有的操作全部都得到了执行并
且不会受到任何因素的干扰而中断，要么所有的操作都不执行。

注意：两个原子性的操作结合在一起未必还是原子性的，比如i++(其中get i，i+1和set i=x三者皆是原子性操作，但是不代表i++就是原子性操作)。volatile关键字不保证数据的原子性，synchronized关键字保证，自JDK 1.5版本起，其提供的原子类型变量也可以保证原子性。

1.2 可见性

可见性是指，当一个线程对共享变量进行了修改，那么另外的线程可以立即看到修改后的最新值

1.3 有序性

所谓有序性是指程序代码在执行过程中的先后顺序， 由于Java在编译器以及运行期的优化，导致了代码的执行顺序未必就是开发者编写代码时的顺序，比如：

  1. int x=10；
  2. in ty=0；
  3. x++；
  4. y=20；

对于这段代码有可能它的执行顺序就是代码本身的顺序，有可能发生了重排序导致int y=0优先于int x=10执行，但是绝对不可能出现y=x+1优先于x++执行的执行情况，如果一个指令x在执行的过程中需要用到指令y的执行结果，那么处理器会保证指令y在指令x之前执行，这就好比y=x+1执行之前肯定要先执行x++一样。

2.JMM三如何保证大特性

Java的内存模型规定了所有的变量都是存在于主内存(RAM) 当中的， 而每个线程都有自己的工作内存或者本地内存(这一点很像CPU的Cache) ， 线程对变量的所有操作都必须在自己的工作内存中进行，而不能直接对主内存进行操作，并且每一个线程都不能访问其他线程的工作内存或者本地内存。

2.1 JMM与原子性

在Java语言中，对基本数据类型的变量读取赋值操作都是原子性的，对引用类型的变量读取和赋值的操作也是原子性的，因此诸如此类的操作是不可被中断的，要么执行，要么不执行，正所谓一荣俱荣一损俱损。
不过话虽如此简单，但是理解起来未必不会出错，下面我们就来看几个例子：
（1）x=10；赋值操作
x=10的操作是原子性的，执行线程首先会将x=10写人工作内存中，然后再将其写入主内存(有可能在往主内存进行数值刷新的过程中其他线程也在对其进行刷新操作，比如另外一个线程将其写为11，但是最终的结果肯定要么是10，要么是11，不可能出现其他情况，单就赋值语句这一点而言其是原子性的)。

（2）y=x; 赋值操作
这条操作语句是非原子性的，因为它包含如下两个重要的步骤。
1)执行线程从主内存中读取x的值(如果x已经存在于执行线程的工作内存中，则直接获取)然后将其存人当前线程的工作内存之中。
2)在执行线程的工作内存中修改y的值为x，然后将y的值写入主内存之中。虽然第一步和第二步都是原子类型的操作，但是合在一起就不是原子操作了。

（3）y++;自增操作
这条操作语句是非原子性的，因为它包含三个重要的步骤，具体如下。
1)执行线程从主内存中读取y的值(如果y已经存在于执行线程的工作内存中，则直接获取)，然后将其存人当前线程的工作内存之中。
2)在执行线程工作内存中为y执行加1操作。
3)将y的值写人主内存。

（4）z = z+1; 加一操作（与自增操作等价）
这条操作语句是非原子性的，因为它包含三个重要的步骤，具体如下。
1)执行线程从主内存中读取z的值(如果z已经存在于执行线程的工作内存中，则直接获取)，然后将其存人当前线程的工作内存之中。
2)在执行线程工作内存中为z执行加1操作。
3)将z的值写入主内存。

由此我们可以得出以下几个结论。

  • 多个原子性的操作在一起就不再是原子性操作了。
  • 简单的读取与赋值操作是原子性的，将一个变量赋给另外一个变量的操作不是原子性的。
  • Java内存模型(JMM) 只保证了基本读取和赋值的原子性操作， 其他的均不保证，如果想要使得某些代码片段具备原子性， 需要使用关键字synchronized， 或者JUC中的lock。如果想要使得int等类型自增操作具备原子性， 可以使用JUC包下的原子封装类型java.util.concurrent.atomic.*

总结：volatile关键字不具备保证原子性的语义

2.2 JMM与可见性

在多线程的环境下，如果某个线程首次读取共享变量，则首先到主内存中获取该变量，然后存入工作内存中，以后只需要在工作内存中读取该变量即可。同样如果对该变量执行了修改的操作，则先将新值写入工作内存中，然后再刷新至主内存中。但是什么时候最新的值会被刷新至主内存中是不太确定的， 这也就解释了为什么Volatile Foo中的Reader线程始终无法获取到in it value最新的变化。

Java提供了以下三种方式来保证可见性。

  • 使用关键字volatile， 当一个变量被volatile关键字修饰时， 对于共享资源的读操作会直接在主内存中进行(当然也会缓存到工作内存中，当其他线程对该共享资源进行了修改，则会导致当前线程在工作内存中的共享资源失效，所以必须从主内存中再次获取)，对于共享资源的写操作当然是先要修改工作内存，但是修改结束后会立刻将其刷新到主内存中。
  • 通过synchronized关键字能够保证可见性， synchronized关键字能够保证同一时刻只有一个线程获得锁，然后执行同步方法，并且还会确保在锁释放之前，会将对变量的修改刷新到主内存当中。
  • 通过JUC提供的显式锁Lock也能够保证可见性， Lock的lock方法能够保证在同一时刻只有一个线程获得锁然后执行同步方法， 并且会确保在锁释放(Lock的unlock方法)之前会将对变量的修改刷新到主内存当中。

总结：volatile关键字具有保证可见性的语义。

2.3 JMM与有序性

在Java的内存模型中， 允许编译器和处理器对指令进行重排序， 在单线程的情况下，重排序并不会引起什么问题，但是在多线程的情况下，重排序会影响到程序的正确运行，Java提供了三种保证有序性的方式， 具体如下。

  • 使用volatile关键字来保证有序性。
  • 使用synchronized关键字来保证有序性。
  • 使用显式锁Lock来保证有序性。

此外，Java的内存模型具备一些天生的有序性规则，不需要任何同步手段就能够保证有序性，这个规则被称为Happens-before原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就无法保证有序性， 也就是说虚拟机或者处理器可以随意对它们进行重排序处理。

下面我们来具体看看都有哪些happens-before原则。

  • 程序次序规则：在一个线程内，代码按照编写时的次序执行，编写在后面的操作发生于编写在前面的操作之后。

这句话的意思看起来是程序按照编写的顺序来执行，但是虚拟机还是可能会对程序代码的指令进行重排序，只要确保在一个线程内最终的结果和代码顺序执行的结果一致即可。

  • 锁定规则：一个unlock操作要先行发生于对同一个锁的lock操作。

这句话的意思是，无论是在单线程还是在多线程的环境下，如果同一个锁是锁定状态，那么必须先对其执行释放操作之后才能继续进行lock操作。

  • volatile变量规则：对一个变量的写操作要早于对这个变量之后的读操作。

根据字面的意思来理解是， 如果一个变量使用volatile关键字修饰， 一个线程对它进行读操作，一个线程对它进行写操作，那么写入操作肯定要先行发生于读操作，关于这个规则我们在3.3节中还会继续介绍。

  • 传递规则：如果操作A先于操作B，而操作Ｂ又先于操作C，则可以得出操作A肯定要先于操作C， 这一点说明了happens-before原则具备传递性。


  • 线程启动规则：Thread对象的start() 方法先行发生于对该线程的任何动作， 这也是我们在第一部分中讲过的， 只有start之后线程才能真正运行， 否则Thread也只是一个对象而已。


  • 线程中断规则：对线程执行interrupt() 方法肯定要优先于捕获到中断信号， 这句话的意思是指如果线程收到了中断信号， 那么在此之前势必要有interrupt() 。


  • 线程的终结规则：线程中所有的操作都要先行发生于线程的终止检测，通俗地讲，线程的任务执行、逻辑单元执行肯定要发生于线程死亡之前。


  • 对象的终结规则：一个对象初始化的完成先行发生于finalize() 方法之前， 这个更没什么好说的了，先有生后有死。

总结： volatile关键字具有保证顺序性的语义

3. volatile关键字深入解析

3.1volatile关键字的语义

被volatile修饰的实例变量或者类变量具备如下两层语义。

  • 保证了不同线程之间对共享变量操作时的可见性， 也就是说当一个线程修改volatile修饰的变量，另外一个线程会立即看到最新的值。
  • 禁止对指令进行重排序操作。

（1）理解volatile保证可见性
关于共享变量在多线程间的可见性， 在Volatile Foo例子中已经体现得非常透彻了，Updater线程对in it_value变量的每一次更改都会使得Reader线程能够看到(在happens-before规则中， 第三条volatile变量规则：对一个变量的写操作要早于对这个变量之后的读操作)，其步骤具体如下。
1) Reader线程从主内存中获取in it_value的值为0， 并且将其缓存到本地工作内存中。
2) Updater线程将in it_value的值在本地工作内存中修改为1， 然后立即刷新至主内
存中。
3) Reader线程在本地工作内存中的in it_value失效(反映到硬件上就是CPU的L 1或
者L 2的CacheLine失效) 。
4) 由于Reader线程工作内存中的in it_value失效， 因此需要到主内存中重新读取in it
value的值。

（2）理解volatile保证顺序性
volatile关键字对顺序性的保证就比较霸道一点， 直接禁止JVM和处理器对volatile关键字修饰的指令重排序， 但是对于volatile前后无依赖关系的指令则可以随便怎么排序，比如

  1. int x= 0;
  2. int y= 1;
  3. volatile int z = 20;
  4. x++;
  5. Y--;

在语句volatile in tz=20之前， 先执行x的定义还是先执行y的定义， 我们并不关心，只要能够百分之百地保证在执行到z=20的时候x=0，y=1，同理关于x的自增以及y的自减操作都必须在z=20以后才能发生。

(3) 理解volatile不保证原子性
i++的操作其实是由三步组成的，具体如下。
1)从主内存中获取i的值，然后缓存至线程工作内存中。
2)在线程工作内存中为i进行加1的操作。
3)将i的最新值写入主内存中。

上面三个操作单独的每一个操作都是原子性操作，但是合起来就不是，因为在执行的中途很有可能会被其他线程打断，例如如下操作情况。
1)假设此时i的值为100，线程A要对变量i执行自增操作，首先它需要到主内存中读取i的值， 可是此时由于CPU时间片调度的关系， 执行权切换到了线程B， A线程进入了RUNNABLE状态而不是RUNNING状态。
2)线程B同样需要从主内存中读取i的值，由于线程A没有对i做过任何修改操作，因此此时B获取到的i仍然是100。
3)线程B工作内存中为i执行了加1操作，但是未刷新至主内存中。
4) CPU时间片的调度又将执行权给了线程A， A线程直接对工作线程中的100进行加1运算(因为A线程已经从主内存中读取了i的值)，由于Ｂ线程并未写人i的最新值，因此A线程工作空间中的100不会被失效。
5)线程A将i=101写人主内存之中。
6)线程B将i=101写入到主内存中。

3.2 volatile的原理和实现机制

通过对Open JDK下unsafe.cpp源码的阅读， 会发现被volatile修饰的变量存在于一个“1ock； ”的前缀， 源码如下：
image.png
“lock； ”前缀实际上相当于是一个内存屏障， 该内存屏障会为指令的执行提供如下几个保障。

  • 确保指令重排序时不会将其后面的代码排到内存屏障之前。
  • 确保指令重排序时不会将其前面的代码排到内存屏障之后。
  • 确保在执行到内存屏障修饰的指令时前面的代码全部执行完成。
  • 强制将线程工作内存中值的修改刷新至主内存中。
  • 如果是写操作， 则会导致其他线程工作内存(CPU Cache) 中的缓存数据失效。

3.3 volatile的使用场景

（1）开关控制利用可见性的特点
（2）状态标记利用顺序性特点
（3）Singleton设计模式的double-check也是利用了顺序性特点

3.4 volatile和synchronized

通过对volatile关键字的学习和之前对synchronized关键字的学习， 我们在这里总结一下两者之间的区别。
（1）使用上的区别

  • volatile关键字只能用于修饰实例变量或者类变量， 不能用于修饰方法以及方法参数和局部变量、常量等。
  • synchronized关键字不能用于对变量的修饰， 只能用于修饰方法或者语句块。
  • volatile修饰的变量可以为null， synchronized关键字同步语句块的monitor对象不能为null。

（2）对原子性的保证

  • volatile无法保证原子性。
  • 由于synchronized是一种排他的机制， 因此被synchronized关键字修饰的同步代码是无法被中途打断的，因此其能够保证代码的原子性。

（3) 对可见性的保证

  • 两者均可以保证共享资源在多线程间的可见性，但是实现机制完全不同。
  • synchronized借助于JVM指令monitor enter和monitor exit对通过排他的方式使得同步代码串行化， 在monitor exit时所有共享资源都将会被刷新到主内存中。
  • 相比较于synchronized关键字volatile使用机器指令(偏硬件) “lock； ”的方式迫使其他线程工作内存中的数据失效，不得到主内存中进行再次加载。

(4) 对有序性的保证

  • volatile关键字禁止JVM编译器以及处理器对其进行重排序， 所以它能够保证有序性。
  • 虽然synchronized关键字所修饰的同步方法也可以保证顺序性， 但是这种顺序性是以程序的串行化执行换来的， 在synchronized关键字所修饰的代码块中代码指令也会发生指令重排序的情况，比如：
  1. synchronized(this) {
  2.     int x=10；
  3.     int y=20；
  4.     x++；
  5.     y=y+1；
  6. }

(5) 其他

  • volatile不会使线程陷入阻塞。
  • synchronized关键字会使线程进人阻塞状态。