JDK1.5 AtomicLong實例

JDK1.5 AtomicLong實例

類 AtomicLong

能夠用原子方式更新的 long 值。有關原子變量屬性的描述，請參閱 java.util.concurrent.atomic 包規範。AtomicLong 可用在應用程序中（如以原子方式增長的序列號），而且不能用於替換 Long。可是，此類確實擴展了 Number，容許那些處理基於數字類的工具和實用工具進行統一訪問。

 

常見方法

long addAndGet(long delta)：以原子方式將給定值與當前值相加。

boolean compareAndSet(long expect, long update)：若是當前值 == 預期值，則以原子方式將該值設置爲給定的更新值。

long decrementAndGet()：以原子方式將當前值減 1。

double doubleValue()：以 double 形式返回指定的數值。

float floatValue()：以 float 形式返回指定的數值。

long get()：獲取當前值。

 

軟件包 java.util.concurrent.atomic

類的小工具包，支持在單個變量上解除鎖定的線程安全編程。

類摘要
AtomicBoolean	能夠用原子方式更新的 boolean 值。
AtomicInteger	能夠用原子方式更新的 int 值。
AtomicIntegerArray	能夠用原子方式更新其元素的 int 數組。
AtomicIntegerFieldUpdater<T>	基於反射的實用工具，能夠對指定類的指定 volatile int 字段進行原子更新。
AtomicLong	能夠用原子方式更新的 long 值。
AtomicLongArray	能夠用原子方式更新其元素的 long 數組。
AtomicLongFieldUpdater<T>	基於反射的實用工具，能夠對指定類的指定 volatile long 字段進行原子更新。
AtomicMarkableReference<V>	AtomicMarkableReference 維護帶有標記位的對象引用，能夠原子方式對其進行更新。
AtomicReference<V>	能夠用原子方式更新的對象引用。
AtomicReferenceArray<E>	能夠用原子方式更新其元素的對象引用數組。
AtomicReferenceFieldUpdater<T,V>	基於反射的實用工具，能夠對指定類的指定 volatile reference 字段進行原子更新。
AtomicStampedReference<V>	AtomicStampedReference 維護帶有整數「標誌」的對象引用，能夠原子方式對其進行更新。

 

實例1：

Java代碼   

1. package com.bijian.thread;  
2.   
3. import java.util.concurrent.atomic.AtomicLong;  
4. import java.util.concurrent.locks.Lock;  
5. public class MyRunnable implements Runnable {  
6.   
7.       private static AtomicLong aLong = new AtomicLong(10000); // 原子量，每一個線程均可以自由操做  
8.        private String name; // 操做人  
9.        private int x; // 操做數額  
10.        private Lock lock;  
11.   
12.        MyRunnable(String name, int x, Lock lock) {  
13.               this.name = name;  
14.               this.x = x;  
15.               this.lock = lock;  
16.        }  
17.   
18.        public void run() {  
19.               System.out.println(name + "執行了" + x + "，當前餘額：" + aLong.addAndGet(x));  
20.               aLong.addAndGet(1);  
21.        }  
22. }  

  

Java代碼   

1. package com.bijian.thread;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5. import java.util.concurrent.locks.Lock;  
6. import java.util.concurrent.locks.ReentrantLock;  
7.   
8. public class Main {  
9.   
10.        public static void main(String[] args) {  
11.   
12.               ExecutorService pool = Executors.newFixedThreadPool(2);  
13.               Lock lock = new ReentrantLock(false);  
14.               Runnable t1 = new MyRunnable("張三", 2000, lock);  
15.               Runnable t2 = new MyRunnable("李四", 3600, lock);  
16.               Runnable t3 = new MyRunnable("王五", 2700, lock);  
17.               Runnable t4 = new MyRunnable("老張", 600, lock);  
18.               Runnable t5 = new MyRunnable("老牛", 1300, lock);  
19.               Runnable t6 = new MyRunnable("胖子", 800, lock);  
20.               // 執行各個線程  
21.                 pool.execute(t1);  
22.               pool.execute(t2);  
23.               pool.execute(t3);  
24.               pool.execute(t4);  
25.               pool.execute(t5);  
26.               pool.execute(t6);  
27.               // 關閉線程池  
28.                 pool.shutdown();  
29.        }  
30. }  

運行結果：

Text代碼   

1. 李四執行了3600，當前餘額：13600  
2. 張三執行了2000，當前餘額：15600  
3. 王五執行了2700，當前餘額：18302  
4. 老張執行了600，當前餘額：18903  
5. 老牛執行了1300，當前餘額：20203  
6. 胖子執行了800，當前餘額：21004  

應該是每一個線程執行後都會執行aLong.addAndGet(1);語句，但實際結果卻不是這樣的，緣由是：雖然long addAndGet(long delta)方法是以原子方式將給定值與當前值相加，但兩條兩句在一塊，也只能表示它們各自的執行是原子級的，它們做爲一個總體卻不是原子級的。

 

因而，咱們稍微修改一下MyRunnable類，給它加上鎖，便可達到咱們預想的目的，以下實例2所示。

實例2（修改MyRunnable類）：

Java代碼   

1. package com.bijian.thread;  
2.   
3.    
4.   
5. import java.util.concurrent.atomic.AtomicLong;  
6.   
7. import java.util.concurrent.locks.Lock;  
8. public class MyRunnable implements Runnable {  
9.   
10.        private static AtomicLong aLong = new AtomicLong(10000); // 原子量，每一個線程均可以自由操做  
11.        private String name; // 操做人  
12.        private int x; // 操做數額  
13.        private Lock lock;  
14.   
15.        MyRunnable(String name, int x, Lock lock) {  
16.   
17.               this.name = name;  
18.               this.x = x;  
19.               this.lock = lock;  
20.        }  
21.   
22.        public void run() {  
23.               lock.lock();  
24.               System.out.println(name + "執行了" + x + "，當前餘額：" + aLong.addAndGet(x));  
25.               aLong.addAndGet(1);  
26.               lock.unlock();  
27.        }  
28. }  

 

運行結果：

Text代碼   

1. 張三執行了2000，當前餘額：12000  
2. 李四執行了3600，當前餘額：15601  
3. 王五執行了2700，當前餘額：18302  
4. 老張執行了600，當前餘額：18903  
5. 胖子執行了800，當前餘額：19704  
6. 老牛執行了1300，當前餘額：21005