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