原子变量(AtomicLong, AtomicInteger, AtomicReference)

原文转载：http://meng-lin.iteye.com/blog/485281，在此基础上加以修改，非常感谢原作者。

多线程 thread 

J2SE 5.0提供了一组atomic class来帮助我们简化同步处理。基本工作原理是使用了同步synchronized的方法实现了对一个long, integer, 对象的增、减、赋值（更新）操作. 比如对于++运算符AtomicInteger可以将它持有的integer 能够atomic 地递增。在需要访问两个或两个以上 atomic变量的程序代码（或者是对单一的atomic变量执行两个或两个以上的操作）通常都需要被synchronize以便两者的操作能够被当作是一个atomic的单元。 

对array atomic变量来说，一次只有一个索引变量可以变动，并没有功能可以对整个array做atomic化的变动。 

关于Atomic的几个方法 
getAndSet() : 设置新值，返回旧值. 
compareAndSet(expectedValue, newValue) : 如果当前值(current value)等于期待的值(expectedValue), 则原子地更新指定值为新值(newValue), 如果更新成功，返回true, 否则返回false, 换句话可以这样说: 将原子变量设置为新的值, 但是如果从我上次看到的这个变量之后到现在被其他线程修改了(和我期望看到的值不符), 那么更新失败 

AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。

来看AtomicInteger提供的接口。

//获取当前的值

public final int get()

//取当前的值，并设置新的值

 public final int getAndSet(int newValue)

//获取当前的值，并自增

 public final int getAndIncrement()

//获取当前的值，并自减

public final int getAndDecrement()

//获取当前的值，并加上预期的值

public final int getAndAdd(int delta)

从effective java (2)中拿来的一个关于AtomicReference的一个例子: 
Java代码 

Java代码  

1. public class AtomicTest {     
2.     private int x, y;     
3.     
4.     private enum State {     
5.         NEW, INITIALIZING, INITIALIZED     
6.     };     
7.     
8.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);     
9.          
10.     public AtomicTest() {     
11.     }     
12.          
13.     public AtomicTest(int x, int y) {     
14.         initialize(x, y);     
15.     }     
16.     
17.     private void initialize(int x, int y) {     
18.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {     
19.             throw new IllegalStateException("initialize is error");     
20.         }     
21.         this.x = x;     
22.         this.y = y;     
23.         init.set(State.INITIALIZED);     
24.     }     
25.     
26.     public int getX() {     
27.         checkInit();     
28.         return x;     
29.     }     
30.     
31.     public int getY() {     
32.         checkInit();     
33.         return y;     
34.     }     
35.          
36.     private void checkInit() {     
37.         if (init.get() == State.INITIALIZED) {     
38.             throw new IllegalStateException("uninitialized");     
39.         }     
40.     }     
41.          
42. }    

上面的例子比较容易懂, 不过貌似没什么价值, 而在实际的应用中, 我们一般采用下面的方式来使用atomic class: 
Java代码 

Java代码  

1. public class CounterTest {     
2.     AtomicInteger counter = new AtomicInteger(0);     
3.     
4.     public int count() {     
5.         int result;     
6.         boolean flag;     
7.         do {     
8.             result = counter.get();     
9.             // 断点     
10.             // 单线程下, compareAndSet返回永远为true,     
11.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,     
12.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值     
13.             flag = counter.compareAndSet(result, result + 1);     
14.         } while (!flag);     
15.     
16.         return result;     
17.     }     
18.     
19.     public static void main(String[] args) {     
20.         final CounterTest c = new CounterTest();     
21.         new Thread() {     
22.             @Override    
23.             public void run() {     
24.                 c.count();     
25.             }     
26.         }.start();     
27.     
28.         new Thread() {     
29.             @Override    
30.             public void run() {     
31.                 c.count();     
32.             }     
33.         }.start();     
34.     
35.         new Thread() {     
36.             @Override    
37.             public void run() {     
38.                 c.count();     
39.             }     
40.         }.start();     
41.     }     
42. }    

类似i++这样的"读-改-写"复合操作(在一个操作序列中, 后一个操作依赖前一次操作的结果), 在多线程并发处理的时候会出现问题, 因为可能一个线程修改了变量, 而另一个线程没有察觉到这样变化, 当使用原子变量之后, 则将一系列的复合操作合并为一个原子操作,从而避免这种问题, i++=>i.incrementAndGet() 
原子变量只能保证对一个变量的操作是原子的, 如果有多个原子变量之间存在依赖的复合操作, 也不可能是安全的, 另外一种情况是要将更多的复合操作作为一个原子操作, 则需要使用synchronized将要作为原子操作的语句包围起来. 因为涉及到可变的共享变量(类实例成员变量)才会涉及到同步, 否则不必使用synchronized

API: http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/atomic/AtomicInteger.html