Java Concurrency #02 - 可見性、原子性、有序性

在多個 Thread 操作的情況下，任一 Thread 修改變數時，其餘 Thread 可看見修改後的變數

public class Example01 {
    private volatile boolean flag = false;

    public void setFlag() {
        flag = true;
    }

    public void loopUntilFlagIsSet() {
        while (!flag) {
            // do nothing
        }
        System.out.println("Flag is set!");
    }

    public static void main(String[] args) {
        Example01 example = new Example01();

        // start a new thread to loop until flag is set
        new Thread(() -> {
            example.loopUntilFlagIsSet();
        }).start();

        // set the flag after a short delay
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        example.setFlag();
        System.out.println("Flag is now set to true.");
    }
}

在一個操作中，不是全部執行成功，就是全部執行失敗

public class Example02 {
    
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        Example02 example = new Example02();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                example.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                example.increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println(example.getCount());
    }

}

在單執行序下，通常不被指令重排影響，但在併發時，我們卻不能保證指令重排後的順序正確性。