全面解析多執行緒與同步技術：SYNC、CAS、ThreadLocal | 公平鎖、可重入鎖、樂觀鎖

● 只對可能產生資源搶奪的區塊進行代碼同步，同步的代碼越長效能越差，因為要做更多的等待

● 我們也可以在創建類時區分 「單執行緒執行環境」、「多執行緒執行環境」，避免統一用多執行環境的物件（這是一種開發上的約束）

認識 this：每一個 物件都有內含 this 關鍵字，它代表的是這個物件的 instance 實例，它是個隱藏物件

當然，請特別注意它鎖定的是「實例」，也就是 多個執行序都要訪問同一個實例，那才有所定的功能；如果多個執行序訪問不同的實例，那就沒有同步的效果

// 同步方法
synchronized void addData() {
    // TODO:
}

// 區塊同步，鎖的物件同上，下一小節會說明…
void addData() {
    synchronized(this) {
        // TODO:
    }
}

--實作--

上面的範例 15 個太多 (不方便觀察)，改為 5 個；可以看到使用兩個 Thread 訪問同一個物件的方法，會依照順序訪問 !

● 透過指定物件而不使用 this 的好處在於，可以更精細的去調整同步，可以有效的提高效率

也就是 可以在一個物件中使用多個「物件（也就是鎖）」，而不是全部執行序都搶 this 這把鎖

● synchronized 指定 this 物件來鎖定，效果跟「synchronized 方法」是一樣的

public void addData() {
    synchronized(this) {
        //TODO:
        }
    }
}

● synchronized 物件指定自己創建物件來鎖定

private Object o = new Object();    // 一定是實例化，不實例化無法作為 key
// or 
// private byte[] b = new byte[0];    // byte[] array 比 Object 需要更小的範圍

public void addData() {
    synchronized(this) {
        //TODO:
        }
    }
}

想解解 Class 最好認識一下 ClassLoader，ClassLoder 知識請點連結

● JVM 內存模型中，靜態方法、物件物件、類 (Class) 都是存在不同地方

目標	內存模型儲存位置	JVM 中物件數量是否單一
靜態方法	方法區	Y
靜態物件	靜態變量區	Y
物件（instance）	堆區	N

// 同步靜態方法
public synchronized static void addData() {
    for(int i = 0; i < 15; i++) {
        x++;
        System.out.println(Thread.currentThread().getName() + ", x: " + x);
    }
}

// 同步靜態物件
private static int x = 0;
private static Object o = new Object();

public void addData() {
    synchronized(o) {
        for(int i = 0; i < 15; i++) {
            x++;
            System.out.println(Thread.currentThread().getName() + ", x: " + x);
        }
    }
}

// 同步 class類物件
public void addData() {
    synchronized(TestSynch.class) {
        for(int i = 0; i < 15; i++) {
            x++;
            System.out.println(Thread.currentThread().getName() + ", x: " + x);
        }
    }
}

● 範例：創建了兩個物件 s1 & s2，用不同線程 t1 & t2 訪問不同物件

● 注意：喚醒是透過物件（鎖）來喚醒，並且喚醒時（notify/notifyAll）是要同一個鎖的物件來喚醒，不同物件（鎖）不能被通知！

public class startThread1 {
    public static void main(String[] args) {
        TestClass t = new TestClass("Alien");
        //t.run();		"1. "
        t.start();

        for(int i = 0; i < 17; i++) {
            t.setTime(i);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

class TestClass extends Thread {

    private String name;
    private int time = 0;

    TestClass(String name) {
        this.name = name;
    }

    void setTime(int time) {
        synchronized(this) {	// "2: "
            this.time = time;
            System.out.println("Now time is " + time);
            this.notifyAll();
        }
    }

    @Override
    public void run() {
        synchronized(this) {        // "3: "
            while(time < 8) {	
                try {
                    System.out.println("Before wait");
                    this.wait(500);    // "4:"
                    System.out.println("After wait");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            /*
            if(time < 8) {		// "5: "
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            */
            System.out.println("Till work time, "+ name + " go to work");	
        }
    }
}

A. 使用 run() 會變成排隊執行（main Thread wait work Thread），導致程式無法正常運作

B. 必須持有「同一把物件（鎖）」，如果持有不同鎖則無法正常喚醒目標物件；this 是指 TestClass 物件鎖(並非類鎖)

C. Java 的每一個物件都可以作為鎖 (Object)

D. wait() 內如果設置時間 (單位預設為ms)，就是限制等待時間，等待時間一過就自動 喚醒；如下圖可以看到，1s 喚醒一次，但 wait 只休息 500ms，所以在 while 內喚醒了 2 次，所以判斷了兩次 (time 相同)

● 執行完同步程式碼區塊

● 出現例外狀況（拋出異常）導致執行序被終止，鎖就會自動釋放（這很重要，避免程序造成死鎖無法正常運行）

● Object#wait 方法：這個方法很特別，它會將當前執行緒掛起（Blocking），並且釋放鎖，讓其他執行序執行該方法！

遞歸的程式設計概念如下

// 概念程式

synchronized int showData(int x) {
    if(x <= 0) {
        return 0;
    }
    return 1 + showData(x - 1);        // 遞歸呼叫，重入同步方法
}

synchronized int showData(int x) {
    System.out.println("x: " + x);
    x--;
    if(x == 0) {
        System.out.println("Reach zero");
        return x;
    }
    return showData(x);    // 遞歸定調用
}

使用 synchronized 關鍵字時，鎖的獲取和釋放是由 Java 虛擬機自動處理的

public synchronized void someMethod() {
    // 此方法由隱式鎖保護
}

public void someMethod() {
    synchronized (this) {
        // 這段代碼由隱式鎖保護
    }
}

當執行序進入 synchronized 區塊或方法時，自動獲取鎖；當執行序離開 synchronized 區塊或方法時，自動釋放鎖

● 明確的加鎖和解鎖：使用 ReentrantLock 時，需要明確地調用 lock() 方法來獲取鎖，並在不需要鎖時調用 unlock() 方法來釋放鎖…

private final ReentrantLock lock = new ReentrantLock();

public void someMethod() {
    lock.lock();
    try {
        // 這段代碼由顯式鎖保護
    } finally {
        lock.unlock();
    }
}

● 高控制度：ReentrantLock 提供了更多功能和更高的控制度，比如可中斷鎖、嘗試獲取鎖以及公平鎖的支持，使得其在需要更複雜同步機制的情況下更具優勢

● 條件變量：ReentrantLock 提供了 Condition 物件，用於實現更複雜的執行序間協調

private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
private boolean ready = false;

public void awaitMethod() throws InterruptedException {
    lock.lock();
    try {
        while (!ready) {
            condition.await();
        }
        // 處理 ready 為 true 時的情況
    } finally {
        lock.unlock();
    }
}

public void signalMethod() {
    lock.lock();
    try {
        ready = true;
        condition.signalAll();
    } finally {
        lock.unlock();
    }
}

ReentrantLock 可以取得多個 Condition 物件，未來可以用在 不同的條件喚醒，使用 一個 condition 對應一個鎖的條件可達到更精準的控制（對於效能也有一定的改善）

Conditoin 的操作必須在 lock & unlock 之間

class TestRETL implements Runnable {

    private ReentrantLock lock = new ReentrantLock();
    private Condition c = lock.newCondition();
    private int a = 0;

    public void compareData() {
        lock.lock();
        try {
            while(a < 8) {
                try {
                    System.out.println("before await");
                    c.await();
                    System.out.println("after await");;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } finally {
            lock.unlock();
        }
        System.out.println("a is 10");
    }

    @Override
    public void run() {
        compareData();
    }

    public void addValue() {
        lock.lock();
        try {
            a++;
            c.signal();
        } finally {
            lock.unlock();
        }
    }
}

--實做--

在一般開發中較少使用公平鎖，如果有需要，也可以使用 ReentrantLock 獲得公平鎖

Lock lock = new ReentrantLock(true);    // 設置為公平鎖

● 非公平鎖的效率較高，為甚麽？

假設喚醒執行序要 1000us 休眠需要 1000us，現在有 A、B、C 執行序，A 搶到鎖(假設鎖的流程 A-B-C)，B 休眠 3s，C 休眠 1s

A. 依照公平鎖，執行順序就是 A-B-C，C 醒後 1000us 會在休眠 1000us，這樣 C 就要喚醒在睡眠花 2000us (因為要等 B 結束)

B. 如果是非公平鎖，執行順序就是先醒 C 的可先搶到資源，並在B 醒之前釋放鎖，這樣效率更高

A. 請求 & 持有 : 當一個執行序持有一個資源後將其保持，並開始請求下一個資源

B. 互斥 : 當一個資源只能有一個執行序持有，當持有後就會鎖住不讓其他執行序獲取該資源

C. 不剝奪 : 當一個執行序獲得資源後，在為完成任務之前是不能被剝奪權力的，只能透過該資源自己釋放

D. 環狀等待 : A 等待 B 釋放資源，但 B 又在等 A 釋放資源

而這些死鎖上的定義也有相對的處理方式

從下面的範例可以看它們 取鎖的順序是相反不同的（兩個執行序對 Lock_1、Lock_2 兩個鎖的順序不同），所以會導致死鎖，如果順序相同就不會產生死鎖 (如果改為相同順序就可以正常取鎖)

// 死鎖範例

public class DeadLock {
    private static Object Lock_1 = new Object();
    private static Object Lock_2 = new Object();


    public static void main(String[] args) {
        new AlienTask().start();
        new KyleTask().start();
        System.out.println("Both Finish Task");
    }

    private static class AlienTask extends Thread {
        @Override
        public void run() {
            synchronized(Lock_1) {
                System.out.println("Alien get Lock_1");
                try {
                    Thread.sleep(100);	// 睡眠 100ms 讓其他執行序搶
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(Lock_2) {
                    System.out.println("Alien get Lock_2");
                }
            }
        }
    }

    private static class KyleTask extends Thread {
        @Override
        public void run() {
            synchronized(Lock_2) {
                System.out.println("Kyle get Lock_2");
                try {
                    Thread.sleep(100);	// 睡眠 100ms 讓其他執行序搶
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(Lock_1) {
                    System.out.println("Kyle get Lock_1");
                }
            }
        }
    }

}

● 如果我們把鎖的順序對調，也就是將兩個執行序取鎖的順序調整為一樣順序，那就可以解開這個死鎖

// 活鎖範例

public class AliveLock {
    public static Lock lock_1 = new ReentrantLock();
    public static Lock lock_2 = new ReentrantLock();

    public static void main(String[] args) {
        new AlienTask_1().start();
        new KyleTask_1().start();
    }

    public static class AlienTask_1 extends Thread {
        @Override
        public void run() {
            while(true) {
                if(lock_1.tryLock()) {
                    System.out.println("Alien get One Lock");
                    try {
                        if(lock_2.tryLock()) {
                            try {
                                System.out.println("Alien get Two Lock");
                                break;
                            } finally {
                                lock_2.unlock();
                            }
                        }
                    } finally {
                        lock_1.unlock();	// 獲取 lock_2 不成功連 lock_1 都釋放
                    }
                } else {
                    System.out.println("Alien get Key failed");
                }
            }
        }
    }

    public static class KyleTask_1 extends Thread {
        @Override
        public void run() {
            while(true) {

                if(lock_2.tryLock()) {
                    System.out.println("Kyle get One Lock");
                    try {
                        if(lock_1.tryLock()) {
                            try {
                                System.out.println("Kyle get Two Key");
                                break;
                            } finally {
                                lock_1.unlock();
                            }
                        }
                    } finally {
                        lock_2.unlock();
                    }
                } else {
                    System.out.println("Kyle get Key failed");
                }	
            }
        }
    }
}

採用嘗試拿鎖的機制，Lock's tryLock 方法等等

--範例--

● 以效率來說是 樂觀鎖的效率會比較高

因為當執行序休眠需要 10000 ~ 20000 個指令時間，而 cpu 假設執行一個指令需要 0.6u 時間，那休眠 + 喚醒一次所花的時間，也就是 20000 * 0.6u * 2 = 24ms，當執行一次作業不需要這麼長時間時就是樂觀鎖效率較高

A. ABA 問題 : CAS 會在放入數值後比對，如果數值如同剛複製的值就設定，否則就再次取值，要考慮到中途可能已經被修改過，然後再次改過來

B. 循環時間開銷大 : 如果一直設定失敗會造成 CPU 負擔，並且花費時間也長，需要衡量

C. 只能保證原子操作 : 如果操作 2 個以上的元素則不保證這 2 個元素都是原子操做，但是可以將 2 個以上的元素包裝成為一個類，對該類進行操作就可以保證原子性

A. AtomicInteger 的使用範例

public class AtomicNormal {

    public static void main(String[] args) {
        Thread[] ts = new Thread[3];
        for(int i = 0; i < 3; i++) {
            ts[i] = new Atomic_Task_1();
        }
        for(int i = 0; i < 3; i++) {
            ts[i].start();
        }
    }

    static class Atomic_Task_1 extends Thread {

        static AtomicInteger ai = new AtomicInteger(10);

        @Override
        public void run() {
            int i = ai.getAndAdd(2);		// Like a++，返回舊值
            System.out.println("Name: " + Thread.currentThread().getName() +
                    ", Old value: " + i + ", now value: " + ai.addAndGet(3)); // ++a，返回新值
        }
    }

}

B. AtomicReference 的使用範例

public class AtomicObject {

    public static void main(String[] args) {
        Thread[] ts = new Thread[3];
        for(int i = 0; i < 3; i++) {
            ts[i] = new Atomic_Task_2(new InfoTable(i, i + 10));
        }
        for(int i = 0; i < 3; i++) {
            ts[i].start();
        }
    }

    static class Atomic_Task_2 extends Thread {
        static AtomicReference<InfoTable> af = new AtomicReference<>(new InfoTable(9527, 24));
        InfoTable temp;

        Atomic_Task_2(InfoTable i) {
            temp = i;
        }

        @Override
        public void run() {
            // 執行到過為止
            while(!af.compareAndSet(af.get(), temp));	//　<比較值>  <新值>

            InfoTable now = af.get();
            System.out.println(now.toString());
        }
    }

    private static class InfoTable {
        private long id;
        private int age;

        InfoTable(long id, int age) {
            this.id = id;
            this.age = age;
        }

        @Override
        public String toString() {
            return "id: " + id + ", age: " + age;
        }
    }

}

C. AtomicStampedReference 的使用範例

public class AtomicStamp {
    static AtomicStampedReference<String> asr = new AtomicStampedReference<>("Pan", 0);

    public static void main(String[] args) throws InterruptedException {

        final int oldStamp = asr.getStamp();
        final String oldRef = asr.getReference();
        System.out.println("old refernece: " + oldRef + ", stamp " + oldStamp + "\n");

        Thread task_1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Task_1" 
                        + ", ref: " + oldRef 
                        + ", Stamp: " + oldStamp + " - "
                        + asr.compareAndSet(oldRef,
                                oldRef + " Hello",
                                oldStamp,
                                oldStamp + 1));
            }
        });

        Thread task_2 = new Thread(new Runnable() {
            @Override
            public void run() {
                String reference = asr.getReference();
                System.out.println("Task_2"
                        + ", ref: " + reference 
                        + ", Stamp：" + asr.getStamp() + " - "
                        + asr.compareAndSet(reference,
                                reference + " World", 
                                oldStamp,
                                oldStamp + 1));
            }
        });

        task_1.start();
        task_2.start();
        Thread.sleep(10);

        System.out.println("\nnow refernece: " + asr.getReference() + ", stamp " + asr.getStamp());
    }
}

// 使用 ThreadLocal

public class ThreadLocalExample {
    // 創建 ThreadLocal，並初始化共享變量
    private static ThreadLocal<Integer> threadLocal = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            new Thread(new Task()).start();
        }
    }

    static class Task implements Runnable {
        @Override
        public void run() {
            int value = threadLocal.get();
            value++;
            threadLocal.set(value);
            System.out.println(Thread.currentThread().getName() + ": " + threadLocal.get());
        }
    }
}

在這個例子中，ThreadLocal 保證每個執行序有自己獨立的 Integer 變量，並且每個執行序修改自己的 Integer 變量而不影響其他執行序

● ThreadLocal 簡單來說就是把共享的變數，拷貝原型後後制到目前所在的執行序中，讓每一個 Thread 都擁有此變數，而該變數互不相干

ThreadLocal 的內部實做是 將靜態變數儲存到 ThreadLocalMap 普通變數，並存於每個 Thread 中，每一個 Thread 都訪問自己的 ThreadLocalMap 來操作這個變數（這樣就是安全的操作）

--實做--

其中的重點有兩個

A. 透過 Map 把執行序作為 Key 來保存，並且在設置、取值的時候都透過 Thread.currentThread() 來取出當前的執行序

B. 需要一把鎖，來鎖定對於 set、get 的操作，來保證多執行序對於 Map 的同步操作（以下用自己創建鎖的方式）

// 手做 ThreadLocal

import java.util.HashMap;
import java.util.Map;


class MyThreadLocal<T> {
    private final Object lock = new Object();

    private T initVal;
    private Map<Thread, T> maps = new HashMap<>();

    public MyThreadLocal(T initVal) {
        this.initVal = initVal;
    }

    public void set(T t) {
        synchronized (lock) {
            Thread thread = Thread.currentThread();

            maps.put(thread, t);
        }
    }

    public T get() {
        synchronized (lock) {
            Thread thread = Thread.currentThread();

            T value = maps.get(thread);

            if (value == null) {
                return initVal;
            }
            return value;
        }
    }
}

public class HandlerThreadLocal {
    private static MyThreadLocal<Integer> threadLocal = new MyThreadLocal<>(0);

    public static void main(String[] args) {
        for(int i = 0; i < 3; i++) {
            new Thread(new MyHandlerTask()).start();
        }
    }

    static class MyHandlerTask implements Runnable {

        @Override
        public void run() {
            int value = threadLocal.get();
            value++;
            threadLocal.set(value);

            System.out.println(Thread.currentThread().getName() +
                    ", hThreadLocal : " + threadLocal.get());
        }
    }
}

以下我們來看看 ThreadLocal#get 操作

// ThreadLocal 源碼的 get() 方法

// Thread 元素
ThreadLocal.ThreadLocalMap threadLocals = null;    // "2. "

public T get() {
    //"1. "
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}


// ThreadLocal 內部類 ThreadLocalMap 的內部類 Entry
static class Entry extends WeakReference<ThreadLocal> {
    Object value;

    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}


// ThreadLocal getEntry(ThreadLocal) 方法
private Entry getEntry(ThreadLocal key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    // "3. "
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

A. 從這裡可以看得出來它是使用 currentThread 當作 key，但是 ThreadLocal 並不是使用 Map 來儲存，而是 TheadLocalMap 這個物件

B. 每一個 Thread 物件中都有 ThreadLocalMap 屬性，該物件也不是靜態物件，當該物件為空時就在內部創建 ThreadLocalMap，而 ThreadLocalMap 內部有一個屬性 Entry[] 數組

C. 使用 ThreadLocal 物件去取，代表 一個 ThreadLocal 物件可以存多個數值，而該數值與其它物件無關

public class DemoTest implements Runnable {
    ThreadLocal<Thread> tl = new ThreadLocal<>();

    @Override 
    public void run() {
        tl.set(1);        // Key : tl, Value : 1
        tl.set(2);        // Key : tl, Value : 2
        tl.set(3);        // Key : tl, Value : 3
    }
}