Java多執行緒3-原子性操作類的使用
摘要：
在java5以後，我們接觸到了執行緒原子性操作，也就是在修改時我們只需要保證它的那個瞬間是安全的即可，經過相應的包裝後可以再處理物件的併發修改，本文總結一下Atomic系列的類的使用方法，其中包含：
原子更新型別
...
在java5以後，我們接觸到了執行緒原子性操作，也就是在修改時我們只需要保證它的那個瞬間是安全的即可，經過相應的包裝後可以再處理物件的併發修改，本文總結一下Atomic系列的類的使用方法，其中包含：
| 原子更新型別 | 名稱 | 描述 |
|---|---|---|
| 基本型別 | AtomicBoolean | 原子更新布林型別 |
| 基本型別 | AtomicInteger | 原子更新整型 |
| 基本型別 | AtomicLong | 原子更新長整型 |
| 陣列型別 | AtomicIntegerArray | 原子更新整型數組裡的元素 |
| 陣列型別 | AtomicLongArray | 原子更新長整型數組裡的元素 |
| 陣列型別 | AtomicReferenceArray | 原子更新引用型別陣列的元素 |
| 陣列型別 | AtomicBooleanArray | 原子更新布林型別陣列的元素 |
| 引用型別 | AtomicReference | 原子更新引用型別 |
| 引用型別 | AtomicReferenceFieldUpdater | 原子更新引用型別裡的欄位 |
| 引用型別 | AtomicMarkableReference | 原子更新帶有標記位的引用型別。可以原子更新一個布林型別的標記位和應用型別 |
| 欄位型別 | AtomicIntegerFieldUpdater | 原子更新整型的欄位的更新器 |
| 欄位型別 | AtomicLongFieldUpdater | 原子更新長整型欄位的更新器 |
| 欄位型別 | AtomicStampedReference | 原子更新帶有版本號的引用型別。該類將整型數值與引用關聯起來，可用於原子的更新資料和資料的版本號，可以解決使用CAS進行原子更新時可能出現的ABA問題。 |
1. 基本型別的使用
public class AtomicTest {
/**
* 常見的方法列表
*
* @see AtomicInteger#get()直接返回值
* @see AtomicInteger#getAndAdd(int)增加指定的資料，返回變化前的資料
* @see AtomicInteger#getAndDecrement() 減少1，返回減少前的資料
* @see AtomicInteger#getAndIncrement() 增加1，返回增加前的資料
* @see AtomicInteger#getAndSet(int)設定指定的資料，返回設定前的資料
* @see AtomicInteger#addAndGet(int)增加指定的資料後返回增加後的資料
* @see AtomicInteger#decrementAndGet() 減少1，返回減少後的值
* @see AtomicInteger#incrementAndGet() 增加1，返回增加後的值
* @see AtomicInteger#lazySet(int)僅僅當get時才會set
* @see AtomicInteger#compareAndSet(int, int) 嘗試新增後對比，若增加成功則返回true否則返回false
**/
public static void main(String[] args) {
final AtomicTicket ticket = new AtomicTicket();
for (int i = 0; i < 3; i++) {
new Thread(new Runnable() {
@Override
public void run() {
while (ticket.getCount() > 0) {
System.out.println(Thread.currentThread().getName() + " count: " + ticket.decrement());
}
}
}).start();
}
}
}
class AtomicTicket {
public AtomicInteger count = new AtomicInteger(100);
public int decrement() {
return count.getAndDecrement();
}
public int getCount() {
return count.get();
}
}
Thread-0 count: 100 Thread-2 count: 98 Thread-1 count: 99 Thread-2 count: 96 Thread-0 count: 97 Thread-2 count: 94 Thread-2 count: 92 Thread-1 count: 95 中間省略... Thread-1 count: 12 Thread-2 count: 7 Thread-0 count: 9 Thread-2 count: 5 Thread-1 count: 6 Thread-2 count: 3 Thread-0 count: 4 Thread-2 count: 1 Thread-1 count: 2
2. 陣列型別的使用
public class AtomicIntegerArrayTest {
/**
* 常見的方法列表
* @see AtomicIntegerArray#addAndGet(int, int) 執行加法，第一個引數為陣列的下標，第二個引數為增加的數量，返回增加後的結果
* @see AtomicIntegerArray#compareAndSet(int, int, int) 對比修改，引數1：陣列下標，引數2：原始值，引數3，修改目標值，修改成功返回true否則false
* @see AtomicIntegerArray#decrementAndGet(int) 引數為陣列下標，將陣列對應數字減少1，返回減少後的資料
* @see AtomicIntegerArray#incrementAndGet(int) 引數為陣列下標，將陣列對應數字增加1，返回增加後的資料
*
* @see AtomicIntegerArray#getAndAdd(int, int) 和addAndGet類似，區別是返回值是變化前的資料
* @see AtomicIntegerArray#getAndDecrement(int) 和decrementAndGet類似，區別是返回變化前的資料
* @see AtomicIntegerArray#getAndIncrement(int) 和incrementAndGet類似，區別是返回變化前的資料
* @see AtomicIntegerArray#getAndSet(int, int) 將對應下標的數字設定為指定值，第二個引數為設定的值，返回是變化前的資料
*/
private final static AtomicIntegerArray ATOMIC_INTEGER_ARRAY = new AtomicIntegerArray(new int[]{1,2,3,4,5,6,7,8,9,10});
public static void main(String []args) throws InterruptedException {
Thread []threads = new Thread[10];
for(int i = 0 ; i < 10 ; i++) {
final int index = i;
threads[i] = new Thread() {
public void run() {
int original =ATOMIC_INTEGER_ARRAY.get(index);
int result = ATOMIC_INTEGER_ARRAY.addAndGet(index, index + 1);
System.out.println("currentThread：" + Thread.currentThread().getName() + " , 原始值為：" + original + "，增加後的結果為：" + result);
}
};
threads[i].start();
}
for(Thread thread : threads) {
thread.join();
}
System.out.println("=========================>\n執行已經完成，結果列表：");
for(int i = 0 ; i < ATOMIC_INTEGER_ARRAY.length() ; i++) {
System.out.println(ATOMIC_INTEGER_ARRAY.get(i));
}
}
}
currentThread：Thread-0 , 原始值為：1，增加後的結果為：2 currentThread：Thread-3 , 原始值為：4，增加後的結果為：8 currentThread：Thread-2 , 原始值為：3，增加後的結果為：6 currentThread：Thread-1 , 原始值為：2，增加後的結果為：4 currentThread：Thread-5 , 原始值為：6，增加後的結果為：12 currentThread：Thread-4 , 原始值為：5，增加後的結果為：10 currentThread：Thread-6 , 原始值為：7，增加後的結果為：14 currentThread：Thread-7 , 原始值為：8，增加後的結果為：16 currentThread：Thread-8 , 原始值為：9，增加後的結果為：18 currentThread：Thread-9 , 原始值為：10，增加後的結果為：20 =========================> 執行已經完成，結果列表： 2 4 6 8 10 12 14 16 18 20
3. 引用型別的使用
public class AtomicReferenceTest {
public static void main(String[] args) {
People people1 =new People("Bom", 0);
People people2 =new People("Tom",10);
//先初始化一個值，如果不初始化則預設值為null
AtomicReference<People> reference = new AtomicReference<>(people1);
People people3 = reference.get();
if (people3.equals(people1)) {
System.out.println("people3:" + people3);
} else {
System.out.println("else:" + people3);
}
/**
* 當前值：拿當前值和reference.get()獲取到的值去比較，如果相等則true並更新值為期望值
* 期望值：如果返回true則更新為期望值，如果返回false則不更新值
*/
boolean b = reference.compareAndSet(null, people2);
System.out.println("myClass.main-"+b+"--"+reference.get());
boolean b1 = reference.compareAndSet(people1, people2);
System.out.println("myClass.main-"+b1+"--"+reference.get());
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
People people = reference.get();
people.setName("Tom"+Thread.currentThread().getName());
people.setAge(people.getAge()+1);
reference.getAndSet(people);
System.out.println(Thread.currentThread().getName()+reference.get().toString());
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
People people = reference.get();
people.setName("Tom"+Thread.currentThread().getName());
people.setAge(people.getAge()+4);
reference.getAndSet(people);
System.out.println(Thread.currentThread().getName()+reference.get().toString());
}
}).start();
}
}
class People {
private String name;
private int age;
public People(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
4.欄位型別的使用
public class AtomicIntegerFieldUpdaterTest {
/**
* 可以直接訪問對應的變數，進行修改和處理
* 條件：要在可訪問的區域內，如果是private或挎包訪問default型別以及非父親類的protected均無法訪問到
* 其次訪問物件不能是static型別的變數（因為在計算屬性的偏移量的時候無法計算），也不能是final型別的變數（因為根本無法修改），必須是普通的成員變數
* <p>
* 方法（說明上和AtomicInteger幾乎一致，唯一的區別是第一個引數需要傳入物件的引用）
*
* @see AtomicIntegerFieldUpdater#addAndGet(Object, int)
* @see AtomicIntegerFieldUpdater#compareAndSet(Object, int, int)
* @see AtomicIntegerFieldUpdater#decrementAndGet(Object)
* @see AtomicIntegerFieldUpdater#incrementAndGet(Object)
* @see AtomicIntegerFieldUpdater#getAndAdd(Object, int)
* @see AtomicIntegerFieldUpdater#getAndDecrement(Object)
* @see AtomicIntegerFieldUpdater#getAndIncrement(Object)
* @see AtomicIntegerFieldUpdater#getAndSet(Object, int)
*/
public final static AtomicIntegerFieldUpdater<A> ATOMIC_INTEGER_UPDATER = AtomicIntegerFieldUpdater.newUpdater(A.class, "intValue");
public static void main(String[] args) {
final A a = new A();
for (int i = 0; i < 10; i++) {
new Thread() {
public void run() {
System.out.println(
Thread.currentThread().getName() + " " + ATOMIC_INTEGER_UPDATER.get(a));
ATOMIC_INTEGER_UPDATER.addAndGet(a, 11);
System.out.println(
Thread.currentThread().getName() + " " + ATOMIC_INTEGER_UPDATER.get(a));
if (ATOMIC_INTEGER_UPDATER.compareAndSet(a, ATOMIC_INTEGER_UPDATER.get(a), 120)) {
System.out.println(Thread.currentThread().getName() + " 對應的值做了修改！");
}
System.out.println(
Thread.currentThread().getName() + " " + ATOMIC_INTEGER_UPDATER.get(a));
}
}.start();
}
}
static class A {
volatile int intValue = 100;
}
}
Thread-0 100 Thread-2 100 Thread-1 100 Thread-2 122 Thread-3 111 Thread-5 120 Thread-0 111 Thread-5 142 Thread-3 131 Thread-2 對應的值做了修改！ Thread-2 120 Thread-8 120 Thread-4 133 Thread-1 133 Thread-9 142 Thread-4 142 Thread-4 對應的值做了修改！ Thread-8 131 Thread-3 對應的值做了修改！ Thread-3 120 Thread-7 120 Thread-7 131 Thread-5 對應的值做了修改！ Thread-5 120 Thread-6 120 Thread-0 對應的值做了修改！ Thread-6 131 Thread-7 對應的值做了修改！ Thread-8 對應的值做了修改！ Thread-4 120 Thread-9 131 Thread-1 對應的值做了修改！ Thread-9 對應的值做了修改！ Thread-8 120 Thread-7 120 Thread-6 對應的值做了修改！ Thread-0 131 Thread-6 120 Thread-9 120 Thread-1 120