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

这篇的主题本应该放在最初的几篇。讨论的是并发编程最基础的几个核心概念。可是这几个概念又牵扯到非常多的实际技术。比方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。

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