多线程-Java原子变量-java.util.concurrent.atomic.*

转载地址：http://blog.csdn.net/a19881029/article/details/8202933

一个没有并发控制的计数器：

[java]  view plain copy

1. public class Counter implements Runnable {  
2.     private static int count;  
3.       
4.     public void run() {  
5.         System.out.println(Thread.currentThread().getName()   
6.                 + ":" + (++count));  
7.     }  
8.       
9.     public static void main(String[] args){  
10.         Counter counter = new Counter();  
11.         Thread t1 = new Thread(counter);  
12.         Thread t2 = new Thread(counter);  
13.         Thread t3 = new Thread(counter);  
14.         Thread t4 = new Thread(counter);  
15.         t1.start();  
16.         t2.start();  
17.         t3.start();  
18.         t4.start();  
19.     }  
20. }  

有时运行正常，但是偶尔会出现如下运行结果：

[plain]  view plain copy

1. Thread-1:2  
2. Thread-0:1  
3. Thread-2:3  
4. Thread-3:3  

这显然和预期结果不太一样，先用javap -verbose命令分析一下这个类，在字节码层面上，++count等价于虚拟机顺次执行如下5条字节码指令（不考虑运行期的优化）

[plain]  view plain copy

1. getstatic  获取指定类的静态域，并将其值压入栈顶  
2. iconst_1   将int型1推送至栈顶  
3. iadd       将栈顶两int型数值相加并将结果压入栈顶  
4. dup        复制栈顶数值并将复制值压入栈顶  
5. putstatic  为指定类的静态域赋值  

当Thread-3线程执行getstatic指令时，Thread-2线程还未执行至iadd指令，故Thread-3线程获取的初始静态域count的值和Thread-2线程一样，都为2

本质原因就是++count虽然只是一行代码，但这一过程并非原子操作

要保证这种类型的原子操作，可以使用java.util.concurrent.atomic包下的类

[plain]  view plain copy

1. 软件包 java.util.concurrent.atomic   
2. 类的小工具包，支持在单个变量上解除锁的线程安全编程。  

示例如下：

[java]  view plain copy

1. public class Counter implements Runnable {  
2.     private final AtomicInteger count = new AtomicInteger(0);  
3.       
4.     public void run() {  
5.         System.out.println(Thread.currentThread().getName()   
6.                 + ":" + count.incrementAndGet());  
7.     }  
8.       
9.     public static void main(String[] args){  
10.         Counter counter = new Counter();  
11.         Thread t1 = new Thread(counter);  
12.         Thread t2 = new Thread(counter);  
13.         Thread t3 = new Thread(counter);  
14.         Thread t4 = new Thread(counter);  
15.         t1.start();  
16.         t2.start();  
17.         t3.start();  
18.         t4.start();  
19.     }  
20. }  

看看源代码中究竟是如何实现的

[java]  view plain copy

1. private volatile int value;  
2.   
3. public AtomicInteger(int initialValue) {  
4.     value = initialValue;  
5. }  
6.   
7. public final int incrementAndGet() {  
8.     for (;;) {  
9.         int current = get();  
10.         int next = current + 1;  
11.         if (compareAndSet(current, next))  
12.             return next;  
13.     }  
14. }  
15.   
16. /** 
17.     * Atomically sets the value to the given updated value 
18.     * if the current value {@code ==} the expected value. 
19.     * 
20.     * @param expect the expected value 
21.     * @param update the new value 
22.     * @return true if successful. False return indicates that 
23.     * the actual value was not equal to the expected value. 
24.     */  
25. public final boolean compareAndSet(int expect, int update) {  
26.     return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
27. }  
28.       
29. public final int get() {  
30.   return value;  
31. }  

是不是和乐观锁很像，如果结果符合预期结果，就将结果返回，否则不断进行重试，并没有进行同步，兼顾了安全性和性能

java.util.concurrent.atomic包下还有很多类，使用这些类可以保证对这些类的诸如“获取-更新”操作是原子性的，从而避发生竞态条件

[plain]  view plain copy

1. AtomicBoolean 可以用原子方式更新的 boolean 值。   
2. AtomicInteger 可以用原子方式更新的 int 值。   
3. AtomicIntegerArray 可以用原子方式更新其元素的 int 数组。   
4. AtomicIntegerFieldUpdater<T> 基于反射的实用工具，可以对指定类的指定 volatile int 字段进行原子更新。   
5. AtomicLong 可以用原子方式更新的 long 值。   
6. AtomicLongArray 可以用原子方式更新其元素的 long 数组。   
7. AtomicLongFieldUpdater<T> 基于反射的实用工具，可以对指定类的指定 volatile long 字段进行原子更新。   
8. AtomicMarkableReference<V> AtomicMarkableReference 维护带有标记位的对象引用，可以原子方式对其进行更新。   
9. AtomicReference<V> 可以用原子方式更新的对象引用。   
10. AtomicReferenceArray<E> 可以用原子方式更新其元素的对象引用数组。   
11. AtomicReferenceFieldUpdater<T,V> 基于反射的实用工具，可以对指定类的指定 volatile 字段进行原子更新。   
12. AtomicStampedReference<V> AtomicStampedReference 维护带有整数“标志”的对象引用，可以用原子方式对其进行更新。