Java并發包中主要基于兩個基礎來建構的，一個是鎖，一個是CAS操作。
- 原子變量提供了與volatile類型變量相同的記憶體語義，此外還支援原子性操作。從JDK1.5開始，提供了
java.util.concurrent.atomic
- 非阻塞算法可以使多個線程在競争相同的資料時不會發生阻塞。獨占鎖可以看做是一種悲觀鎖，它假設隻要有線程進入就會導緻錯誤，是以隻在確定無其它線程進入的時候才進行操作；非阻塞算法，則隻關心結果，如果結果錯誤了，那麼重新再來，對于錯誤選擇原諒，而不是想進辦法防止其它線程進入，使用非阻塞算法無需關心其它線程。
Java中對非阻塞算法的支援是
java.util.concurrent.atomic
包中的原子類。
原子類劃分
基本類型：AtomicBoolean,AtomicInteger,AtomicLong
數組： AtomicIntegerArray,AtomicLongArray,AtomicRefernceArray
引用類型：AtomicReference, AtomicReferenceFieldUpdater,AtomicMarkableReference
字段類：AtomicIntegerFieldUpdater,AtomicLongFieldUpdater,AtomicStampedReference
CAS算法
原子類的操作本質上都是CAS算法的實作。
CAS算法過程：
CAS包含了3個操作數，需要讀寫的記憶體位置V，進行比較的值E(exists)，和要寫入的值N(new)。
當且僅當V的值等于E的值的時候，才會把V的值設定成N。最後CAS傳回V的真實值。
原子類案例
原子類是一種更好的volatile變量，之前我們保證同步的措施是使用加鎖的機制，無需加鎖，也可以做到。
原子類的核心API實作
基本上所有原子類都有這些API，它們的操作也都是利用這些API實作的。而這些API又都是利用Unsafe類來實作的。
如果我們直接執行個體化Unsafe類，系統會報
SecurityException
異常，平時開發中也不建議使用Unsafe類來做各種操作，但是有關Unsafe類的一些用法可以了解下。
Unsafe類可以直接操作記憶體層面上的資料。
compareAndSet(V,E,N)
//在對象var1變量上，var2為位址，var4期望的值，var5位要設定的新值。
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
原子類基本類型案例
// 計數器案例
public class IntegerDemo implements Runnable{
static AtomicInteger count = new AtomicInteger(0);
static int THREAD_COUNT = 100;
@Override
public void run() {
for (int i = 0; i < 100; i++) {
// CAS自增語句
count.incrementAndGet();
}
}
public static void main(String[] args) throws InterruptedException {
IntegerDemo demo = new IntegerDemo();
Thread[] threads = new Thread[THREAD_COUNT];
for (int i = 0; i < THREAD_COUNT; i++) {
threads[i] = new Thread(demo);
threads[i].start();
}
for (int i = 0; i < THREAD_COUNT; i++) {
threads[i].join();
}
System.out.println(count.get());
}
}
//可以看到每次結果都是: 10000
這段代碼中重要的是原子類的incrementAndGet方法，看一下内部實作。
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
// 不斷循環，以確定值正确
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
原子引用類型案例
關于AtomicRefernce的使用
public class ReferenceDemo {
private static AtomicReference<Integer> count = new AtomicReference<>(0);
public static void main(String[] args) {
count.compareAndSet(0, 2); // 2
count.compareAndSet(0, 1); // no
count.compareAndSet(1, 3); // no
count.compareAndSet(2, 4); // 4
count.compareAndSet(3, 5); // no
System.out.println(count.get());
}
}
//運作結果得4
//通過CAS算法，修改對象成員變量的值
// 要求成員變量是非靜态類型變量最好是volatile修飾的
public class ReferenceFiledUpdaterDemo {
private static AtomicIntegerFieldUpdater<ReferenceFiledUpdaterDemo> updater =
AtomicIntegerFieldUpdater.newUpdater(ReferenceFiledUpdaterDemo.class, "count");
@Getter
public volatile int count = 100;
public static void main(String[] args) {
ReferenceFiledUpdaterDemo demo = new ReferenceFiledUpdaterDemo();
if (updater.compareAndSet(demo, 100, 120)) {
System.out.println(("update success 1 :" + demo.getCount()));
}
if (updater.compareAndSet(demo, 100, 120)) {
System.out.println(("update success 2 :" + demo.getCount()));
} else {
System.out.println(("update failed :" + demo.getCount()));
}
}
}
//運作結果
update success :120
update failed, {} :120
AtomicReference無法解決ABA問題，所謂ABA問題，對象在某一段時間内被寫入了兩次，首先修改為其它的值，然後又修改回原來的值，而另外一個線程再去讀的時候值并沒有變化，如何知道對象是否被修改過呢？
JDK中引入了AtomicStampedReference，它維護了一個時間戳，更新資料的時候還要更新時間戳，當對象值，及時間戳都滿足期望值的時候才能寫入成功。
原子類數組案例
AtomicArray的核心API
public class AtomicArrayDemo {
static AtomicIntegerArray arr = new AtomicIntegerArray(10);
public static class SubThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
arr.getAndDecrement( i % arr.length() );
}
}
}
public static void main(String[] args) {
Runnable demo = new SubThread();
ExecutorService service = Executors.newFixedThreadPool(10);
for (int i = 0; i < 10; i++) {
service.submit(demo);
}
service.shutdown();
System.out.println(arr);
}
}
//運作結果
[-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000]
三種原子性機制對比
對比
最後
這次主要對原子類相關的内容做了簡單的說明，需要明白原子類的用法以及Unsafe類的一些事項。
參考
- Java Magic. Part 4: sun.misc.Unsafe
- 《Java并發程式設計實戰》
- 《Java高并發程式設計》