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