共享模型之CAS無鎖（樂觀鎖，非阻塞）

本文的主要內容有：

1、問題提出：轉賬案例

解決思路-無鎖

class AccountCas implements Account {
    private AtomicInteger balance;  //使用原子整形AtomicInteger 

    public AccountCas(int balance) {
        this.balance = new AtomicInteger(balance);
    }

    @Override
    public Integer getBalance() {
        return balance.get();    
    }

    @Override
    public void withdraw(Integer amount) {
        while(true) {
            // 獲取餘額的最新值
            int prev = balance.get();
            // 要修改的餘額
            int next = prev - amount;
            // 真正修改
            if(balance.compareAndSet(prev, next)) {
                break;	  //如果最新的餘額與之前的餘額不一致繼續下一輪循環，一致則退出循環	
            }
        }
    }
}

2、CAS 與 volatile

前面看到的 AtomicInteger 的解決方法，內部並沒有用鎖來保護共享變量的線程安全。那麼它是如何實現的呢？

  public void withdraw(Integer amount) {
        while(true) {
            // 獲取餘額的最新值
            int prev = balance.get();
            // 要修改的餘額
            int next = prev - amount;
           /* compareAndSet 正是做這個檢查，在 set 前，先比較 prev 與當前值
			 - 不一致了，next 作廢，返回 false 表示失敗
			 比如，別的線程已經做了減法，當前值已經被減成了 990
			 那麼本線程的這次 990 就作廢了，進入 while 下次循環重試
			 - 一致，以 next 設置爲新值，返回 true 表示成功*/
            // 真正修改
            if(balance.compareAndSet(prev, next)) {
                break;	  //如果最新的餘額與之前的餘額不一致繼續下一輪循環，一致則退出循環	
            }
        }
    }

其中的關鍵是 compareAndSet，它的簡稱就是 CAS （也有 Compare And Swap 的說法），它必須是原子操作。

volatile

爲什麼無鎖效率高?

3、原子整數

以 AtomicInteger 爲例

AtomicInteger i = new AtomicInteger(0);
// 獲取並自增（i = 0, 結果 i = 1, 返回 0），類似於 i++
System.out.println(i.getAndIncrement());
// 自增並獲取（i = 1, 結果 i = 2, 返回 2），類似於 ++i
System.out.println(i.incrementAndGet());
// 自減並獲取（i = 2, 結果 i = 1, 返回 1），類似於 --i
System.out.println(i.decrementAndGet());
// 獲取並自減（i = 1, 結果 i = 0, 返回 1），類似於 i--
System.out.println(i.getAndDecrement());
// 獲取並加值（i = 0, 結果 i = 5, 返回 0）
System.out.println(i.getAndAdd(5));
// 加值並獲取（i = 5, 結果 i = 0, 返回 0）
System.out.println(i.addAndGet(-5));
// 獲取並更新（i = 0, p 爲 i 的當前值, 結果 i = -2, 返回 0）
// 其中函數中的操作能保證原子，但函數需要無副作用
System.out.println(i.getAndUpdate(p -> p - 2));
// 更新並獲取（i = -2, p 爲 i 的當前值, 結果 i = 0, 返回 0）
// 其中函數中的操作能保證原子，但函數需要無副作用
System.out.println(i.updateAndGet(p -> p + 2));
// 獲取並計算（i = 0, p 爲 i 的當前值, x 爲參數1, 結果 i = 10, 返回 0）
// 其中函數中的操作能保證原子，但函數需要無副作用
// getAndUpdate 如果在 lambda 中引用了外部的局部變量，要保證該局部變量是 final 的
// getAndAccumulate 可以通過 參數1 來引用外部的局部變量，但因爲其不在 lambda 中因此不必是 final
System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
// 計算並獲取（i = 10, p 爲 i 的當前值, x 爲參數1, 結果 i = 0, 返回 0）
// 其中函數中的操作能保證原子，但函數需要無副作用
System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));

updateAndGet原理：

   public static int updateAndGet(AtomicInteger i, IntUnaryOperator operator) {
        while (true) {
            int prev = i.get();
            int next = operator.applyAsInt(prev);
            if (i.compareAndSet(prev, next)) {
                return next;
            }
        }
    }

4、原子引用

安全實現-使用鎖（略）
安全實現-使用CAS

class DecimalAccountCas implements DecimalAccount {
    private AtomicReference<BigDecimal> balance;

    public DecimalAccountCas(BigDecimal balance) {
//        this.balance = balance;
        this.balance = new AtomicReference<>(balance);
    }

    @Override
    public BigDecimal getBalance() {
        return balance.get();
    }

    @Override
    public void withdraw(BigDecimal amount) {
        while(true) {
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

ABA 問題及解決
ABA 問題

static AtomicReference<String> ref = new AtomicReference<>("A");
public static void main(String[] args) throws InterruptedException {
	 log.debug("main start...");
	 // 獲取值 A
	 // 這個共享變量被它線程修改過？
	 String prev = ref.get();
	 other();   //
	 sleep(1); 
	 // 嘗試改爲 C
	 log.debug("change A->C {}", ref.compareAndSet(prev, "C"));
	}
	
private static void other() {
	 new Thread(() -> {
	 	log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));
	 }, "t1").start();
	 sleep(0.5)
	 new Thread(() -> {
	 	log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));
	 }, "t2").start();
}

輸出

11:29:52.325 c.Test36 [main] - main start... 
11:29:52.379 c.Test36 [t1] - change A->B true 
11:29:52.879 c.Test36 [t2] - change B->A true 
11:29:53.880 c.Test36 [main] - change A->C true

主線程僅能判斷出共享變量的值與最初值 A 是否相同，不能感知到這種從 A 改爲 B 又改回 A 的情況，如果主線程希望：只要有其它線程【動過了】共享變量，那麼自己的 cas 就算失敗，這時，僅比較值是不夠的，需要再加一個版本號。
AtomicStampedReference

static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args) throws InterruptedException {
	 log.debug("main start...");
	 // 獲取值 A
	 String prev = ref.getReference();  //之前是ref.get(),這裏是getReference()
	 // 獲取版本號
	 int stamp = ref.getStamp();
	 log.debug("版本 {}", stamp);
	 // 如果中間有其它線程干擾，發生了 ABA 現象
	 other();
	 sleep(1);
	 // 嘗試改爲 C
	 log.debug("change A->C {}", ref.compareAndSet(prev, "C", stamp, stamp + 1));
	}
	
private static void other() {
	 new Thread(() -> {
		 log.debug("change A->B {}", ref.compareAndSet(ref.getReference(), "B", 
		 ref.getStamp(), ref.getStamp() + 1));
		 log.debug("更新版本爲 {}", ref.getStamp());
	 }, "t1").start();
	 sleep(0.5);
	 new Thread(() -> {
	 	log.debug("change B->A {}", ref.compareAndSet(ref.getReference(), "A", 
	 	ref.getStamp(), ref.getStamp() + 1));
	 	log.debug("更新版本爲 {}", ref.getStamp());
	 }, "t2").start();
}

輸出

 c.Test36 [main] - main start... 
15:41:34.894 c.Test36 [main] - 版本 0 
15:41:34.956 c.Test36 [t1] - change A->B true 
15:41:34.956 c.Test36 [t1] - 更新版本爲 1 
15:41:35.457 c.Test36 [t2] - change B->A true 
15:41:35.457 c.Test36 [t2] - 更新版本爲 2 
15:41:36.457 c.Test36 [main] - change A->C false

AtomicStampedReference 可以給原子引用加上版本號，追蹤原子引用整個的變化過程，如： A -> B -> A -> C ，通過AtomicStampedReference，我們可以知道，引用變量中途被更改了幾次。
但是有時候，並不關心引用變量更改了幾次，只是單純的關心是否更改過，所以就有了：AtomicMarkableReference

AtomicMarkableReference

class GarbageBag {
	 String desc;
	 public GarbageBag(String desc) {
	 this.desc = desc;
	 }
	 public void setDesc(String desc) {
	 	this.desc = desc;
	  }
	 @Override
	 public String toString() {
	 	return super.toString() + " " + desc;
	 }
}

@Slf4j
public class TestABAAtomicMarkableReference {
	 public static void main(String[] args) throws InterruptedException {
	 GarbageBag bag = new GarbageBag("裝滿了垃圾");
	 // 參數2 mark 可以看作一個標記，表示垃圾袋滿了
	 AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
	 log.debug("主線程 start...");
	 GarbageBag prev = ref.getReference();
	 log.debug(prev.toString());
	 new Thread(() -> {
		 log.debug("打掃衛生的線程 start...");
		 bag.setDesc("空垃圾袋");
		 while (!ref.compareAndSet(bag, bag, true, false)) {}
		 log.debug(bag.toString());
	 }).start();
	 Thread.sleep(1000);
	 log.debug("主線程想換一隻新垃圾袋？");
	 boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
	 log.debug("換了麼？" + success);
	 log.debug(ref.getReference().toString());
	 }
}

輸出

2019-10-13 15:30:09.264 [main] 主線程 start... 
2019-10-13 15:30:09.270 [main] cn.itcast.GarbageBag@5f0fd5a0 裝滿了垃圾
2019-10-13 15:30:09.293 [Thread-1] 打掃衛生的線程 start... 
2019-10-13 15:30:09.294 [Thread-1] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋
2019-10-13 15:30:10.294 [main] 主線程想換一隻新垃圾袋？
2019-10-13 15:30:10.294 [main] 換了麼？false 
2019-10-13 15:30:10.294 [main] cn.itcast.GarbageBag@5f0fd5a0 空垃圾袋

可以註釋掉打掃衛生線程代碼，再觀察輸出

5、原子數組

/**
 參數1，提供數組、可以是線程不安全數組或線程安全數組
 參數2，獲取數組長度的方法
 參數3，自增方法，回傳 array, index
 參數4，打印數組的方法
*/
// supplier 提供者 無中生有 ()->結果
// function 函數 一個參數一個結果 (參數)->結果 , BiFunction (參數1,參數2)->結果
// consumer 消費者 一個參數沒結果 (參數)->void, BiConsumer (參數1,參數2)->
private static <T> void demo(
	 Supplier<T> arraySupplier,
	 Function<T, Integer> lengthFun,
	 BiConsumer<T, Integer> putConsumer,
	 Consumer<T> printConsumer ) {
	 List<Thread> ts = new ArrayList<>();
	 T array = arraySupplier.get();
	 int length = lengthFun.apply(array);
	 for (int i = 0; i < length; i++) {
		 // 每個線程對數組作 10000 次操作
		 ts.add(new Thread(() -> {
			 for (int j = 0; j < 10000; j++) {
			 	putConsumer.accept(array, j%length);
			 }
		 }));
	 }
	 ts.forEach(t -> t.start()); // 啓動所有線程
	 ts.forEach(t -> {
		 try {
		 	t.join();
		 } catch (InterruptedException e) {
		 	e.printStackTrace();
		 }
 }); // 等所有線程結束
 printConsumer.accept(array);
}

不安全的數組

demo(
	 ()->new int[10],
	 (array)->array.length,
	 (array, index) -> array[index]++,
	 array-> System.out.println(Arrays.toString(array))
);

結果

[9870, 9862, 9774, 9697, 9683, 9678, 9679, 9668, 9680, 9698]

安全的數組

demo(
	 ()-> new AtomicIntegerArray(10),
	 (array) -> array.length(),
	 (array, index) -> array.getAndIncrement(index),
	 array -> System.out.println(array)
);

結果

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

6、字段更新器

利用字段更新器，可以針對對象的某個域（Field）進行原子操作，只能配合 volatile 修飾的字段使用，否則會出現異常。

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

public class Test5 {
	 private volatile int field;
	 public static void main(String[] args) {
		 AtomicIntegerFieldUpdater fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");
		 Test5 test5 = new Test5();
		 fieldUpdater.compareAndSet(test5, 0, 10);
		 // 修改成功 field = 10
		 System.out.println(test5.field);
		 // 修改成功 field = 20
		 fieldUpdater.compareAndSet(test5, 10, 20);
		 System.out.println(test5.field);
		 // 修改失敗 field = 20
		 fieldUpdater.compareAndSet(test5, 10, 30);
		 System.out.println(test5.field);
	 }
}

7、原子累加器

private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
	 T adder = adderSupplier.get();
	 long start = System.nanoTime();
	 List<Thread> ts = new ArrayList<>();
	 // 4 個線程，每人累加 50 萬
	 for (int i = 0; i < 40; i++) {
		 ts.add(new Thread(() -> {
		 for (int j = 0; j < 500000; j++) {
		 	action.accept(adder);
		 }
		 }));
	 }
	 ts.forEach(t -> t.start());
	 ts.forEach(t -> {
		 try {
		 	t.join();
		 } catch (InterruptedException e) {
		 	e.printStackTrace();
		}
	 });
	 long end = System.nanoTime();
	 System.out.println(adder + " cost:" + (end - start)/1000_000);
}

比較 AtomicLong 與 LongAdder

for (int i = 0; i < 5; i++) {
 	demo(() -> new LongAdder(), adder -> adder.increment());
}
for (int i = 0; i < 5; i++) {
 	demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());
}

輸出

1000000 cost:43 
1000000 cost:9 
1000000 cost:7 
1000000 cost:7 
1000000 cost:7 

1000000 cost:31 
1000000 cost:27 
1000000 cost:28 
1000000 cost:24 
1000000 cost:22

性能提升的原因很簡單，就是在有競爭時，設置多個累加單元，Therad-0 累加 Cell[0]，而 Thread-1 累加Cell[1]… 最後將結果彙總。這樣它們在累加時操作的不同的 Cell 變量，因此減少了 CAS 重試失敗，從而提高性能。

8、 Unsafe
Unsafe 對象提供了非常底層的，操作內存、線程的方法，Unsafe 對象不能直接調用，只能通過反射獲得

/*Unsafe類*/
public final class Unsafe {
    private static final Unsafe theUnsafe;  //私有成員變量
    public static final int INVALID_FIELD_OFFSET = -1;
    public static final int ARRAY_BOOLEAN_BASE_OFFSET;
    public static final int ARRAY_BYTE_BASE_OFFSET;
    public static final int ARRAY_SHORT_BASE_OFFSET;
    public static final int ARRAY_CHAR_BASE_OFFSET;
........

/*通過反射獲取Unsafe對象*/
import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class UnsafeAccessor {
    private static final Unsafe unsafe;

    static {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");//私有變量用getDeclaredField,公有用getField
            theUnsafe.setAccessible(true); //設置可訪問私有成員變量
            unsafe = (Unsafe) theUnsafe.get(null); //由於是靜態成員變量爲類類型不是對象類型，賦值爲null
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new Error(e);
        }
    }

    public static Unsafe getUnsafe() {
        return unsafe;
    }
}

Unsafe CAS 操作

@Data
class Student {
 volatile int id;
 volatile String name; 
 }

Unsafe unsafe = UnsafeAccessor.getUnsafe();
Field id = Student.class.getDeclaredField("id");
Field name = Student.class.getDeclaredField("name");
// 獲得成員變量的偏移量
long idOffset = UnsafeAccessor.unsafe.objectFieldOffset(id);
long nameOffset = UnsafeAccessor.unsafe.objectFieldOffset(name);

Student student = new Student();
// 使用 cas 方法替換成員變量的值
UnsafeAccessor.unsafe.compareAndSwapInt(student, idOffset, 0, 20); // 返回 true
UnsafeAccessor.unsafe.compareAndSwapObject(student, nameOffset, null, "張三"); // 返回 true
System.out.println(student);

輸出

Student(id=20, name=張三)

使用自定義的測試類實現之前線程安全的原子整數 Account 實現

import lombok.extern.slf4j.Slf4j;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;

@Slf4j(topic = "c.Test35")
public class Test35 {
    public static void main(String[] args) {
        DecimalAccount.demo(new DecimalAccountCas(new BigDecimal("10000")));
    }
}

class DecimalAccountCas implements DecimalAccount {
    private AtomicReference<BigDecimal> balance;

    public DecimalAccountCas(BigDecimal balance) {
//        this.balance = balance;
        this.balance = new AtomicReference<>(balance);
    }

    @Override
    public BigDecimal getBalance() {
        return balance.get();
    }

    @Override
    public void withdraw(BigDecimal amount) {
        while(true) {
            BigDecimal prev = balance.get();
            BigDecimal next = prev.subtract(amount);
            if (balance.compareAndSet(prev, next)) {
                break;
            }
        }
    }
}

interface DecimalAccount {
    // 獲取餘額
    BigDecimal getBalance();

    // 取款
    void withdraw(BigDecimal amount);

    /**
     * 方法內會啓動 1000 個線程，每個線程做 -10 元 的操作
     * 如果初始餘額爲 10000 那麼正確的結果應當是 0
     */
    static void demo(DecimalAccount account) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(BigDecimal.TEN);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println(account.getBalance());
    }
}

共享模型之CAS無鎖（樂觀鎖，非阻塞）

共享模型之CAS無鎖（樂觀鎖，非阻塞）

Mysql的性能優化的幾個小技巧

JVM學習筆記（二）(類加載與字節碼技術)，看這篇文章就夠了

JVM學習筆記（一）(JVM介紹、JVM內存結構、垃圾回收)，看這篇文章就夠了

共享模型之CAS無鎖（樂觀鎖，非阻塞）

併發編程進階之----共享模型之不可變

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結