臨界區互斥通路的方法

0 同步機制遵循準則

1. 空閑讓進：臨界區空閑時，允許請求進入臨界區
2. 忙則等待：有線程進入臨界區時，其他線程必須等待
3. 有限等待：等待不能無限制持續下去
4. 讓權等待：釋放等待線程的 CPU 資源

1 單标志

問題：違背空閑讓進（當有一個線程結束，另外一個即使沒有結束也無法進入臨界區）

public class SingleFlag {
    public static volatile boolean flag;
    public static volatile int num = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                while (flag) ;
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag = false;
            }
        }).start();

        new Thread(() -> {
            while (true) {
                while (flag) ;
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag = true;
            }
        }).start();
    }
}
           

2 雙标志先檢查

問題：違背忙則等待（恰好執行完 1 時線程切換，此時 2 判斷也能通過，則會存在安全問題）

public class DoubleFlag {
    public static volatile boolean[] flag={false, true};
    public static volatile int num = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                while (flag[0]); // 1
                flag[1] = true; 
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag[1] = false;
            }
        }).start();

        new Thread(() -> {
            while (true) {
                while (flag[1]); // 2
                flag[0] = true; 
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag[0] = false;
            }
        }).start();
    }
}
           

3 雙标志後檢查

問題：違背有限等待原則（兩個線程無限制謙讓，導緻活鎖）

public class DoubleFlagAfterCheck {
    public static volatile boolean[] flag = {false, true};
    public static volatile int num = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                flag[1] = true; 
                while (flag[0]);
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag[1] = false;
            }
        }).start();

        new Thread(() -> {
            while (true) {
                flag[0] = true; 
                while (flag[1]);
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag[0] = false;
            }
        }).start();
    }
}
           

4 Peterson

完美解決并發安全性問題

問題：無法達到讓權等待（CPU 一直在死循環判斷，占用 CPU 資源）

public class Peterson {
    public static volatile boolean[] flag = {false, false};
    public static volatile int turn = 0;
    public static volatile int num = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            while (true) {
                flag[0] = true;
                turn = 2;
                while (flag[1] && turn == 2) ;
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag[0] = false;
            }

        }).start();

        new Thread(() -> {
            while (true) {
                flag[1] = true;
                turn = 1;
                while (flag[0] && turn == 1) ;
                System.out.println(Thread.currentThread().getName() + " " + ++num);
                flag[1] = false;
            }
        }).start();
    }
}