为什么volatile不能保证原子性？
在上篇《非阻塞同步算法与cas(compare and swap)无锁算法》中讲到在java中long赋值不是原子操作，因为先写32位，再写后32位，分两步操作，而atomiclong赋值是原子操作，为什么？为什么volatile能替代简单的锁，却不能保证原子性？这里面涉及volatile，是java中的一个我觉得这个词在java规范中从未被解释清楚的神奇关键词，在sun的jdk官方文档是这样形容volatile的：
the java programming language provides a second mechanism, volatile fields, that is more convenient than locking for some purposes. a field may be declared volatile, in which case the java memory model ensures that all threads see a consistent value for the variable.
意思就是说，如果一个变量加了volatile关键字，就会告诉编译器和jvm的内存模型：这个变量是对所有线程共享的、可见的，每次jvm都会读取最新写入的值并使其最新值在所有cpu可见。volatile似乎是有时候可以代替简单的锁，似乎加了volatile关键字就省掉了锁。但又说volatile不能保证原子性（java程序员很熟悉这句话：volatile仅仅用来保证该变量对所有线程的可见性，但不保证原子性）。这不是互相矛盾吗？
不要将volatile用在getandoperate场合，仅仅set或者get的场景是适合volatile的
不要将volatile用在getandoperate场合（这种场合不原子，需要再加锁），仅仅set或者get的场景是适合volatile的。
volatile没有原子性举例：atomicinteger自增
例如你让一个volatile的integer自增（i++），其实要分成3步：1）读取volatile变量值到local； 2）增加变量的值；3）把local的值写回，让其它的线程可见。这3步的jvm指令为：
|
1
2
3
4
|
mov 0xc(%r10),%r8d ; load
inc %r8d ; incrementmov %r8d,0xc(%r10) ; store
lock addl $0x0,(%rsp) ; storeload barrier
|
注意最后一步是内存屏障。
什么是内存屏障（memory barrier）？
内存屏障（memory barrier）是一个cpu指令。基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和cpu可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉cpu和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同cpu的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗cpu执行的。
内存屏障（memory barrier）和volatile什么关系？上面的虚拟机指令里面有提到，如果你的字段是volatile，java内存模型将在写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作，你必须知道：1、一旦你完成写入，任何访问这个字段的线程将会得到最新的值。2、在你写入前，会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，因为内存屏障会把之前的写入值都刷新到缓存。
volatile为什么没有原子性?
明白了内存屏障（memory barrier）这个cpu指令，回到前面的jvm指令：从load到store到内存屏障，一共4步，其中最后一步jvm让这个最新的变量的值在所有线程可见，也就是最后一步让所有的cpu内核都获得了最新的值，但中间的几步（从load到store）是不安全的，中间如果其他的cpu修改了值将会丢失。下面的测试代码可以实际测试voaltile的自增没有原子性：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
private static volatile long _longval = 0;
private static class loopvolatile implements runnable {
public void run() {
long val = 0;
while (val < 10000000l) {
_longval++;
val++;
}
}
}
private static class loopvolatile2 implements runnable {
public void run() {
long val = 0;
while (val < 10000000l) {
_longval++;
val++;
}
}
}
private void testvolatile(){
thread t1 = new thread(new loopvolatile());
t1.start();
thread t2 = new thread(new loopvolatile2());
t2.start();
while (t1.isalive() || t2.isalive()) {
}
system.out.println("final val is: " + _longval);
}
output:------------- final val is: 11223828
final val is: 17567127
final val is: 12912109
|
volatile没有原子性举例：singleton单例模式实现
这是一段线程不安全的singleton（单例模式）实现，尽管使用了volatile：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class wrongsingleton {
private static volatile wrongsingleton _instance = null;
private wrongsingleton() {}
public static wrongsingleton getinstance() {
if (_instance == null) {
_instance = new wrongsingleton();
}
return _instance;
}
} |
下面的测试代码可以测试出是线程不安全的：
原因自然和上面的例子是一样的。因为volatile保证变量对线程的可见性，但不保证原子性。
附：正确线程安全的单例模式写法：
|
1
2
3
4
5
6
7
8
9
|
@threadsafepublic class safelazyinitialization {
private static resource resource;
public synchronized static resource getinstance() {
if (resource == null)
resource = new resource();
return resource;
}
} |
另外一种写法：
|
1
2
3
4
5
|
@threadsafepublic class eagerinitialization {
private static resource resource = new resource();
public static resource getresource() { return resource; }
} |
延迟初始化的写法：
|
1
2
3
4
5
6
7
8
9
|
@threadsafepublic class resourcefactory {
private static class resourceholder {
public static resource resource = new resource();
}
public static resource getresource() {
return resourceholder.resource ;
}
} |
二次检查锁定/double checked locking的写法（反模式）
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public class singletondemo {
private static volatile singletondemo instance = null;//注意需要volatile
private singletondemo() { }
public static singletondemo getinstance() {
if (instance == null) { //二次检查，比直接用独占锁效率高
synchronized (singletondemo .class){
if (instance == null) {
instance = new singletondemo ();
}
}
}
return instance;
}
} |
为什么atomicxxx具有原子性和可见性？
就拿atomiclong来说，它既解决了上述的volatile的原子性没有保证的问题，又具有可见性。它是如何做到的？当然就是上文《非阻塞同步算法与cas(compare and swap)无锁算法》提到的cas（比较并交换）指令。 其实atomiclong的源码里也用到了volatile，但只是用来读取或写入，见源码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class atomiclong extends number implements java.io.serializable {
private volatile long value;
/**
* creates a new atomiclong with the given initial value.
*
* @param initialvalue the initial value
*/
public atomiclong(long initialvalue) {
value = initialvalue;
}
/**
* creates a new atomiclong with initial value {@code 0}.
*/
public atomiclong() {
}
|
其cas源码核心代码为：
|
1
2
3
4
5
6
7
8
9
|
int compare_and_swap (int* reg, int oldval, int newval)
{ atomic();
int old_reg_val = *reg;
if (old_reg_val == oldval)
*reg = newval;
end_atomic();
return old_reg_val;
} |
虚拟机指令为：
|
1
2
3
4
|
mov 0xc(%r11),%eax ; load
mov %eax,%r8d inc %r8d ; incrementlock cmpxchg %r8d,0xc(%r11) ; compare and exchange
|
因为cas是基于乐观锁的，也就是说当写入的时候，如果寄存器旧值已经不等于现值，说明有其他cpu在修改，那就继续尝试。所以这就保证了操作的原子性。
转载：http://www.cnblogs.com/mainz/p/3556430.html#