java—atomic

 

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, 换句话可以这样说: 将原子变量设置为新的值, 但是如果从我上次看到的这个变量之后到现在被其他线程修改了(和我期望看到的值不符), 那么更新失败

从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. }     
43.   
44. public class AtomicTest {   
45.     private int x, y;   
46.   
47.     private enum State {   
48.         NEW, INITIALIZING, INITIALIZED   
49.     };   
50.   
51.     private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);   
52.        
53.     public AtomicTest() {   
54.     }   
55.        
56.     public AtomicTest(int x, int y) {   
57.         initialize(x, y);   
58.     }   
59.   
60.     private void initialize(int x, int y) {   
61.         if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {   
62.             throw new IllegalStateException("initialize is error");   
63.         }   
64.         this.x = x;   
65.         this.y = y;   
66.         init.set(State.INITIALIZED);   
67.     }   
68.   
69.     public int getX() {   
70.         checkInit();   
71.         return x;   
72.     }   
73.   
74.     public int getY() {   
75.         checkInit();   
76.         return y;   
77.     }   
78.        
79.     private void checkInit() {   
80.         if (init.get() == State.INITIALIZED) {   
81.             throw new IllegalStateException("uninitialized");   
82.         }   
83.     }   
84.        
85. }  

public class AtomicTest {       private int x, y;         private enum State {           NEW, INITIALIZING, INITIALIZED       };         private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);              public AtomicTest() {       }              public AtomicTest(int x, int y) {           initialize(x, y);       }         private void initialize(int x, int y) {           if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {               throw new IllegalStateException("initialize is error");           }           this.x = x;           this.y = y;           init.set(State.INITIALIZED);       }         public int getX() {           checkInit();           return x;       }         public int getY() {           checkInit();           return y;       }              private void checkInit() {           if (init.get() == State.INITIALIZED) {               throw new IllegalStateException("uninitialized");           }       }          }  public class AtomicTest {private int x, y;private enum State {NEW, INITIALIZING, INITIALIZED};private final AtomicReference<State> init = new AtomicReference<State>(State.NEW);public AtomicTest() {}public AtomicTest(int x, int y) {initialize(x, y);}private void initialize(int x, int y) {if (!init.compareAndSet(State.NEW, State.INITIALIZING)) {throw new IllegalStateException("initialize is error");}this.x = x;this.y = y;init.set(State.INITIALIZED);}public int getX() {checkInit();return x;}public int getY() {checkInit();return y;}private void checkInit() {if (init.get() == State.INITIALIZED) {throw new IllegalStateException("uninitialized");}}}

上面的例子比较容易懂, 不过貌似没什么价值, 而在实际的应用中, 我们一般采用下面的方式来使用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. }     
43.   
44. public class CounterTest {   
45.     AtomicInteger counter = new AtomicInteger(0);   
46.   
47.     public int count() {   
48.         int result;   
49.         boolean flag;   
50.         do {   
51.             result = counter.get();   
52.             // 断点   
53.             // 单线程下, compareAndSet返回永远为true,  
54.             // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,  
55.             // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值  
56.             flag = counter.compareAndSet(result, result + 1);   
57.         } while (!flag);   
58.   
59.         return result;   
60.     }   
61.   
62.     public static void main(String[] args) {   
63.         final CounterTest c = new CounterTest();   
64.         new Thread() {   
65.             @Override  
66.             public void run() {   
67.                 c.count();   
68.             }   
69.         }.start();   
70.   
71.         new Thread() {   
72.             @Override  
73.             public void run() {   
74.                 c.count();   
75.             }   
76.         }.start();   
77.   
78.         new Thread() {   
79.             @Override  
80.             public void run() {   
81.                 c.count();   
82.             }   
83.         }.start();   
84.     }   
85. }  

public class CounterTest {       AtomicInteger counter = new AtomicInteger(0);         public int count() {           int result;           boolean flag;           do {               result = counter.get();               // 断点               // 单线程下, compareAndSet返回永远为true,               // 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,               // 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值               flag = counter.compareAndSet(result, result + 1);           } while (!flag);             return result;       }         public static void main(String[] args) {           final CounterTest c = new CounterTest();           new Thread() {               @Override              public void run() {                   c.count();               }           }.start();             new Thread() {               @Override              public void run() {                   c.count();               }           }.start();             new Thread() {               @Override              public void run() {                   c.count();               }           }.start();       }   }  public class CounterTest {AtomicInteger counter = new AtomicInteger(0);public int count() {int result;boolean flag;do {result = counter.get();// 断点// 单线程下, compareAndSet返回永远为true,// 多线程下, 在与result进行compare时, counter可能被其他线程set了新值, 这时需要重新再取一遍再比较,// 如果还是没有拿到最新的值, 则一直循环下去, 直到拿到最新的那个值flag = counter.compareAndSet(result, result + 1);} while (!flag);return result;}public static void main(String[] args) {final CounterTest c = new CounterTest();new Thread() {@Overridepublic void run() {c.count();}}.start();new Thread() {@Overridepublic void run() {c.count();}}.start();new Thread() {@Overridepublic void run() {c.count();}}.start();}}

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