聊聊高并发（十九）理解并发编程的几种"性" -- 可见性，有序性，原子性

这篇的主题本应该放在最初的几篇，讨论的是并发编程最基础的几个核心概念，但是这几个概念又牵扯到很多的实际技术，比如Java内存模型，各种锁的实现，volatile的实现，原子变量等等，每一个都可以展开写很多，尤其是Java内存模型，网上已经能够有很几篇不错的文章，暂时不想重复造轮子，这里推荐几篇Jave内存模型的资料:

1.
JSR-133 FAQ

2. JSR-133 Cookbook

3. Synchronization and Java Memory Model

4.
深入理解Java内存模型

我之前也写了一个Java内存模型的PPT: http://share.csdn.net/slides/7916
下面说说并发编程关注的几个核心概念。关注一个并发问题，有3个基本的关注点：

1. 安全性，也就是正确性，指的是程序在并发情况下执行的结果和预期一致

2. 活跃性，比如死锁，活锁

3. 性能，减少上下文切换，减少内核调用，减少一致性流量等等

安全性问题是首要解决的问题，保证程序的线程安全，实际上就是对多线程的同步，而多线程的同步本质上就是多线程通信的问题。操作系统里面定义了几种进程通信的方式：

1. 管道 pipeline

2. 信号 signal

3. 消息队列 messsage queue

4. 共享内存 shared memory

5. 信号量 semaphore

6. Socket

Java里面进行多线程通信的主要方式就是共享内存的方式，共享内存主要的关注点有两个：可见性和有序性。加上复合操作的原子性，我们可以认为Java的线程安全性问题主要关注点有3个

1. 可见性

2. 有序性

3. 原子性

Java内存模型JMM解决了可见性和有序性的问题，而锁解决了原子性的问题。

至于Java内存模型如何解决可见性和有序性的问题，以后会说到，感兴趣的同学可以看看上面的资料。

可见性指的是一个线程对变量的写操作对其他线程后续的读操作可见。由于现代CPU都有多级缓存，CPU的操作都是基于高速缓存的，而线程通信是基于内存的，这中间有一个Gap, 可见性的关键还是在对变量的写操作之后能够在某个时间点显示地写回到主内存，这样其他线程就能从主内存中看到最新的写的值。volatile，synchronized, 显式锁，原子变量这些同步手段都可以保证可见性。可见性底层的实现是通过加内存屏障实现的：

1. 写变量后加写屏障，保证CPU写缓冲区的值强制刷新回主内存

2. 读变量之前加读屏障，使缓存失效，从而强制从主内存读取变量最新值

写volatile变量 = 进入锁

读volatile变量 = 释放锁

有序性指的是数据不相关的变量在并发的情况下，实际执行的结果和单线程的执行结果是一样的，不会因为重排序的问题导致结果不可预知。volatile, final, synchronized，显式锁都可以保证有序性。

有序性的语意有几层，

1. [b]最常见的就是保证多线程执行的串行顺序

2. 防止重排序引起的问题

3. 程序执行的先后顺序，比如JMM定义的一些Happens-before规则

[/b]

重排序的问题是一个单独的主题，常见的重排序有3个层面:

1. 编译级别的重排序，比如编译器的优化

2. 指令级重排序，比如CPU指令执行的重排序

3. 内存系统的重排序，比如缓存和读写缓冲区导致的重排序

原子性是指某个(些)操作在语意上是原子的。比如读操作，写操作，CAS(compare and set)操作在机器指令级别是原子的，又比如一些复合操作在语义上也是原子的，如先检查后操作if(xxx == null){}

有个专有名词竞态条件来描述原子性的问题。

竞态条件(racing condition)是指某个操作由于不同的执行时序而出现不同的结果，比如先检查后操作。

volatile变量只保证了可见性，不保证原子性， 比如a++这种操作在编译后实际是多条语句，比如先读a的值，再加1操作，再写操作，执行了3个原子操作，如果并发情况下，另外一个线程很有可能读到了中间状态，从而导致程序语意上的不正确。所以a++实际是一个复合操作。

加锁可以保证复合语句的原子性，sychronized可以保证多条语句在synchronized块中语意上是原子的。显式锁保证临界区的原子性。原子变量也封装了对变量的原子操作。非阻塞容器也提供了原子操作的接口，比如putIfAbsent。

理解可见性，有序性，原子性是理解并发编程的一个重要基础