6、原子性、可见性和有序性以及原因

1. 三大性质简介

synchronized: 具有原子性，有序性和可见性 ；  volatile：具有有序性和可见性

在并发编程中分析线程安全的问题时往往需要切入点，那就是 两大核心 ：JMM抽象内存模型以及happens-before规则（在 这篇文章 中已经经过了），三条性质： 原子性，有序性和可见性 。关于 synchronized 和 volatile 已经讨论过了，就想着将并发编程中这两大神器在  原子性，有序性和可见性 上做一个比较，当然这也是面试中的高频考点，值得注意。

2. 原子性

原子性是指 一个操作是不可中断的，要么全部执行成功要么全部执行失败，有着“同生共死”的感觉 。及时在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程所干扰。我们先来看看哪些是原子操作，哪些不是原子操作，有一个直观的印象：

int a = 10; //1

a++; //2

int b=a; //3

a = a+1; //4

上面这四个语句中只 有第1个语句是原子操作 ，将10赋值给线程工作内存的变量a,而语句2（a++），实际上包含了三个操作：1. 读取变量a的值；2：对a进行加一的操作；3.将计算后的值再赋值给变量a，而这三个操作无法构成原子操作。对语句3,4的分析同理可得这两条语句不具备原子性。当然， java内存模型 中定义了8中操作都是原子的，不可再分的。

1. lock(锁定)：作用于主内存中的变量，它把一个变量标识为一个线程独占的状态；
2. unlock(解锁):作用于主内存中的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
3. read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便后面的load动作使用；
4. load（载入）：作用于工作内存中的变量，它把read操作从主内存中得到的变量值放入工作内存中的变量副本
5. use（使用）：作用于工作内存中的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作；
6. assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；
7. store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送给主内存中以便随后的write操作使用；
8. write（操作）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

上面的这些指令操作是相当底层的，可以作为扩展知识面掌握下。那么如何理解这些指令了?比如，把一个变量从主内存中复制到工作内存中就需要执行read,load操作，将工作内存同步到主内存中就需要执行store,write操作。注意的是： java内存模型只是要求上述两个操作是顺序执行的并不是连续执行的 。也就是说read和load之间可以插入其他指令，store和writer可以插入其他指令。比如对主内存中的a,b进行访问就可以出现这样的操作顺序： read a,read b, load b,load a 。

由原子性变量操作read,load,use,assign,store,write，可以 大致认为基本数据类型的访问读写具备原子性 （例外就是long和double的非原子性协定）

synchronized

上面一共有八条原子操作，其中六条可以满足基本数据类型的访问读写具备原子性，还剩下lock和unlock两条原子操作。如果我们需要更大范围的原子性操作就可以使用lock和unlock原子操作。尽管jvm没有把lock和unlock开放给我们使用，但jvm以更高层次的指令monitorenter和monitorexit指令开放给我们使用，反应到java代码中就是---synchronized关键字，也就是说 synchronized满足原子性 。

volatile 我们先来看这样一个例子：

public class VolatileExample {

private static volatile int counter = 0;

 

public static void main(String[] args) {

for (int i = 0; i < 10; i++) {

Thread thread = new Thread(new Runnable() {

@Override

public void run() {

for (int i = 0; i < 10000; i++)

counter++;

}

});

thread.start();

}

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(counter);

}

}

开启10个线程，每个线程都自加10000次，如果不出现线程安全的问题最终的结果应该就是：10*10000 = 100000;可是运行多次都是小于100000的结果，问题在于  volatile并不能保证原子性 ，在前面说过counter++这并不是一个原子操作，包含了三个步骤：1.读取变量counter的值；2.对counter加一；3.将新值赋值给变量counter。如果线程A读取counter到工作内存后，其他线程对这个值已经做了自增操作后，那么线程A的这个值自然而然就是一个过期的值，因此，总结果必然会是小于100000的。

为什么 volatile不能保证原子性：

    这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

 

假如某个时刻变量inc的值为10，

　　线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；

　　然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。

　　然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

　　那么两个线程分别进行了一次自增操作后，inc只增加了1。

　　解释到这里，可能有朋友会有疑问，不对啊，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，对，这个没错。这个就是上面的happens-before规则中的volatile变量规则，但是要注意，线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

　　根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

如果让volatile保证原子性，必须符合以下两条规则：

1. 运算结果并不依赖于变量的当前值，或者能够确保只有一个线程修改变量的值；
2. 变量不需要与其他的状态变量共同参与不变约束

3. 有序性

synchronized

synchronized语义表示锁在同一时刻只能由一个线程进行获取，当锁被占用后，其他线程只能等待。因此，synchronized语义就要求线程在访问读写共享变量时只能“串行”执行，因此 synchronized具有有序性 。

volatile

在java内存模型中说过，为了性能优化，编译器和处理器会进行指令重排序；也就是说java程序天然的有序性可以总结为： 如果在本线程内观察，所有的操作都是有序的；如果在一个线程观察另一个线程，所有的操作都是无序的 。在单例模式的实现上有一种双重检验锁定的方式（Double-checked Locking）。代码如下：

public class Singleton {

private Singleton() { }

private volatile static Singleton instance;

public Singleton getInstance(){

if(instance==null){

synchronized (Singleton.class){

if(instance==null){

instance = new Singleton();

}

}

}

return instance;

}

}

这里为什么要加volatile了？我们先来分析一下不加volatile的情况，有问题的语句是这条：

instance = new Singleton();

这条语句实际上包含了三个操作：1.分配对象的内存空间；2.初始化对象；3.设置instance指向刚分配的内存地址。但由于存在重排序的问题，可能有以下的执行顺序：

 

如果2和3进行了重排序的话，线程B进行判断if(instance==null)时就会为true，而实际上这个instance并没有初始化成功，显而易见对线程B来说之后的操作就会是错得。而 用volatile修饰 的话就可以禁止2和3操作重排序，从而避免这种情况。 volatile包含禁止指令重排序的语义，其具有有序性 。

 

　有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：

 

 

int i = 0 ;

 

boolean flag = false ;

 

i = 1 ; //语句1

 

flag = true ; //语句2

 　　上面代码定义了一个int型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序（Instruction Reorder）。

　　下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

　　比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

　　但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？再看下面一个例子：

 

 

int a = 10 ; //语句1

 

int r = 2 ; //语句2

 

a = a + 3 ; //语句3

 

r = a*a; //语句4

 　　这段代码有4个语句，那么可能的一个执行顺序是：

　　  

　那么可不可能是这个执行顺序呢： 语句2   语句1    语句4   语句3

　　不可能，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

　　虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：

 

 

//线程1:

 

context = loadContext(); //语句1

 

inited = true ; //语句2

 

 

 

//线程2:

 

while (!inited ){

 

sleep()

 

}

 

doSomethingwithconfig(context);

 　　上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。

 　　从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

　　也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

 

4. 可见性

可见性是指当一个线程修改了共享变量后，其他线程能够立即得知这个修改。通过之前对 synchronzed 内存语义进行了分析，当线程获取锁时会从主内存中获取共享变量的最新值，释放锁的时候会将共享变量同步到主内存中。从而， synchronized具有可见性 。同样的在 volatile分析中 ，会通过在指令中添加 lock指令 ，以实现内存可见性。因此,  volatile具有可见性

5. 总结

通过这篇文章，主要是比较了synchronized和volatile在三条性质：原子性，可见性，以及有序性的情况，归纳如下：

synchronized: 具有原子性，有序性和可见性 ；  volatile：具有有序性和可见性

处 理器如何 实现 原子操作

（ 1 ）使用 总线锁 保 证 原子性

第一个机制是通 过总线锁 保 证 原子性：

    所 谓总线锁 就是使用 处 理器提供的一个LOCK＃信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该

处 理器可以独占共享内存。

第二个机制是通 过缓 存 锁 定来保 证 原子性：

    频 繁使用的内存会 缓 存在 处 理器的 L1 、 L2 和 L3 高速 缓 存里，那么原子操作就可以直接在处理器内部缓存中进行，并不需要声明总线锁，在Pentium 6和目前的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性

 

但是有两种情况下 处 理器不会使用 缓 存 锁 定。

第一种情况是：当操作的数据不能被 缓 存在 处 理器内部，或操作的数据跨多个 缓 存行 （ cache line ） 时 ， 则处 理器会 调 用 总线锁 定。 第二种情况是：有些 处 理器不支持 缓 存 锁 定。 对 于 Intel 486 和 Pentium 处 理器，就算 锁 定的 内存区域在 处 理器的 缓 存行中也会 调 用 总线锁 定。