转载自&＃xff1a;http://www.cnblogs.com/Mainz/p/3556430.html
在Java中long赋值不是原子操作&＃xff0c;因为先写32位&＃xff0c;再写后32位&＃xff0c;分两步操作&＃xff0c;而AtomicLong赋值是原子操作&＃xff0c;为什么&＃xff1f;为什么volatile能替代简单的锁&＃xff0c;却不能保证原子性&＃xff1f;这里面涉及volatile&＃xff0c;是java中的一个我觉得这个词在Java规范中从未被解释清楚的神奇关键词&＃xff0c;在Sun的JDK官方文档是这样形容volatile的&＃xff1a;
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.
意思就是说&＃xff0c;如果一个变量加了volatile关键字&＃xff0c;就会告诉编译器和JVM的内存模型&＃xff1a;这个变量是对所有线程共享的、可见的&＃xff0c;每次jvm都会读取最新写入的值并使其最新值在所有CPU可见。volatile似乎是有时候可以代替简单的锁&＃xff0c;似乎加了volatile关键字就省掉了锁。但又说volatile不能保证原子性&＃xff08;java程序员很熟悉这句话&＃xff1a;volatile仅仅用来保证该变量对所有线程的可见性&＃xff0c;但不保证原子性&＃xff09;。这不是互相矛盾吗&＃xff1f;
不要将volatile用在getAndOperate场合&＃xff0c;仅仅set或者get的场景是适合volatile的
不要将volatile用在getAndOperate场合&＃xff08;这种场合不原子&＃xff0c;需要再加锁&＃xff09;&＃xff0c;仅仅set或者get的场景是适合volatile的。
volatile没有原子性举例&＃xff1a;AtomicInteger自增
例如你让一个volatile的integer自增&＃xff08;i&＃43;&＃43;&＃xff09;&＃xff0c;其实要分成3步&＃xff1a;1&＃xff09;读取volatile变量值到local&＃xff1b; 2&＃xff09;增加变量的值&＃xff1b;3&＃xff09;把local的值写回&＃xff0c;让其它的线程可见。这3步的jvm指令为&＃xff1a;
| 1 2 3 4 | mov 0xc(%r10),%r8d ; Load inc %r8d ; Increment mov %r8d,0xc(%r10) ; Store lock addl $0x0,(%rsp) ; StoreLoad Barrier |
注意最后一步是内存屏障。
什么是内存屏障&＃xff08;Memory Barrier&＃xff09;&＃xff1f;
内存屏障&＃xff08;memory barrier&＃xff09;是一个CPU指令。基本上&＃xff0c;它是这样一条指令&＃xff1a; a) 确保一些特定操作执行的顺序&＃xff1b; b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序&＃xff0c;使性能得到优化。插入一个内存屏障&＃xff0c;相当于告诉CPU和编译器先于这个命令的必须先执行&＃xff0c;后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如&＃xff0c;一个写屏障会把这个屏障前写入的数据刷新到缓存&＃xff0c;这样任何试图读取该数据的线程将得到最新值&＃xff0c;而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。
内存屏障&＃xff08;memory barrier&＃xff09;和volatile什么关系&＃xff1f;上面的虚拟机指令里面有提到&＃xff0c;如果你的字段是volatile&＃xff0c;Java内存模型将在写操作后插入一个写屏障指令&＃xff0c;在读操作前插入一个读屏障指令。这意味着如果你对一个volatile字段进行写操作&＃xff0c;你必须知道&＃xff1a;1、一旦你完成写入&＃xff0c;任何访问这个字段的线程将会得到最新的值。2、在你写入前&＃xff0c;会保证所有之前发生的事已经发生&＃xff0c;并且任何更新过的数据值也是可见的&＃xff0c;因为内存屏障会把之前的写入值都刷新到缓存。
volatile为什么没有原子性?
明白了内存屏障&＃xff08;memory barrier&＃xff09;这个CPU指令&＃xff0c;回到前面的JVM指令&＃xff1a;从Load到store到内存屏障&＃xff0c;一共4步&＃xff0c;其中最后一步jvm让这个最新的变量的值在所有线程可见&＃xff0c;也就是最后一步让所有的CPU内核都获得了最新的值&＃xff0c;但中间的几步&＃xff08;从Load到Store&＃xff09;是不安全的&＃xff0c;中间如果其他的CPU修改了值将会丢失。下面的测试代码可以实际测试voaltile的自增没有原子性&＃xff1a;
volatile没有原子性举例&＃xff1a;singleton单例模式实现
这是一段线程不安全的singleton&＃xff08;单例模式&＃xff09;实现&＃xff0c;尽管使用了volatile&＃xff1a;
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | public class wrongsingleton { private static volatile wrongsingleton _instance &＃61; null; private wrongsingleton() {} public static wrongsingleton getInstance() { if (_instance &＃61;&＃61; null) { _instance &＃61; new wrongsingleton(); } return _instance; } } |
下面的测试代码可以测试出是线程不安全的&＃xff1a;
原因自然和上面的例子是一样的。因为volatile保证变量对线程的可见性&＃xff0c;但不保证原子性。
附&＃xff1a;正确线程安全的单例模式写法&＃xff1a;
| 1 2 3 4 5 6 7 8 9 | &＃64;ThreadSafe public class SafeLazyInitialization { private static Resource resource; public synchronized static Resource getInstance() { if (resource &＃61;&＃61; null) resource &＃61; new Resource(); return resource; } } |
另外一种写法&＃xff1a;
| 1 2 3 4 5 | &＃64;ThreadSafe public class EagerInitialization { private static Resource resource &＃61; new Resource(); public static Resource getResource() { return resource; } } |
延迟初始化的写法&＃xff1a;
| 1 2 3 4 5 6 7 8 9 | &＃64;ThreadSafe public class ResourceFactory { private static class ResourceHolder { public static Resource resource &＃61; new Resource(); } public static Resource getResource() { return ResourceHolder.resource ; } } |
二次检查锁定/Double Checked Locking的写法&＃xff08;反模式&＃xff09;
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | public class SingletonDemo { private static volatile SingletonDemo instance &＃61; null; private SingletonDemo() { } public static SingletonDemo getInstance() { if (instance &＃61;&＃61; null) { synchronized (SingletonDemo .class){ if (instance &＃61;&＃61; null) { instance &＃61; new SingletonDemo (); } } } return instance; } } |
为什么AtomicXXX具有原子性和可见性&＃xff1f;
就拿AtomicLong来说&＃xff0c;它既解决了上述的volatile的原子性没有保证的问题&＃xff0c;又具有可见性。它是如何做到的&＃xff1f;当然就是上文《非阻塞同步算法与CAS(Compare and Swap)无锁算法》提到的CAS&＃xff08;比较并交换&＃xff09;指令。 其实AtomicLong的源码里也用到了volatile&＃xff0c;但只是用来读取或写入&＃xff0c;见源码&＃xff1a;
| 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. * * &＃64;param initialValue the initial value */ public AtomicLong(long initialValue) { value &＃61; initialValue; } /** * Creates a new AtomicLong with initial value {&＃64;code 0}. */ public AtomicLong() { } |
其CAS源码核心代码为&＃xff1a;
| 1 2 3 4 5 6 7 8 9 | int compare_and_swap (int* reg, int oldval, int newval) { ATOMIC(); int old_reg_val &＃61; *reg; if (old_reg_val &＃61;&＃61; oldval) *reg &＃61; newval; END_ATOMIC(); return old_reg_val; } |
虚拟机指令为&＃xff1a;
| 1 2 3 4 | mov 0xc(%r11),%eax ; Load mov %eax,%r8d inc %r8d ; Increment lock cmpxchg %r8d,0xc(%r11) ; Compare and exchange |
因为CAS是基于乐观锁的&＃xff0c;也就是说当写入的时候&＃xff0c;如果寄存器旧值已经不等于现值&＃xff0c;说明有其他CPU在修改&＃xff0c;那就继续尝试。所以这就保证了操作的原子性。
![[大整数乘法] java代码实现](https://img1.php1.cn/3cd4a/24c6f/9f3/0133bb25da242824.jpeg)
京公网安备 11010802041100号