public class ConcurrencyProblems {
    private static boolean ready = false;
    private static int number = 0;
    public static void main(String[] args) {
        // 線程1：數(shù)據(jù)準(zhǔn)備
        Thread writer = new Thread(() -> {
            number = 42;    // 操作1：可能被重排序到操作2之后
            ready = true;   // 操作2：可能先執(zhí)行
        });
        // 線程2：數(shù)據(jù)處理
        Thread reader = new Thread(() -> {
            while (!ready) {
                // 等待ready變?yōu)閠rue
                Thread.yield();
            }
            // 可能輸出0而不是42！
            System.out.println("Number: " + number);
        });
        writer.start();
        reader.start();
    }
}

public class MemoryOperations {
    private int sharedValue = 0;
    public void operationExample() {
        // 1. read: 從主內(nèi)存讀取變量到傳輸通道
        // 2. load: 將read得到的值放入工作內(nèi)存的變量副本
        // 相當(dāng)于: int temp = sharedValue; (但這是高級(jí)語(yǔ)言表示)
        // 3. use: 將工作內(nèi)存中的變量傳遞給執(zhí)行引擎
        int result = sharedValue * 2;
        // 4. assign: 將執(zhí)行引擎的結(jié)果賦給工作內(nèi)存中的變量
        sharedValue = result + 1;
        // 5. store: 將工作內(nèi)存中的變量值傳輸?shù)街鲀?nèi)存的傳輸通道
        // 6. write: 將store獲取的值放入主內(nèi)存的變量
        // 7. lock: 將主內(nèi)存變量標(biāo)記為線程獨(dú)占狀態(tài)
        // 8. unlock: 釋放鎖定的變量
    }
}

public class VolatileExample {
    private volatile boolean flag = false;
    private int value = 0;
    public void writer() {
        value = 42;      // 普通寫操作
        // StoreStore內(nèi)存屏障：禁止上面的普通寫與下面的volatile寫重排序
        flag = true;     // volatile寫操作
        // StoreLoad內(nèi)存屏障：確保volatile寫立即對(duì)其他處理器可見
    }
    public void reader() {
        // LoadLoad內(nèi)存屏障：確保volatile讀之前的所有讀操作已完成
        if (flag) {      // volatile讀操作
            // LoadStore內(nèi)存屏障：確保volatile讀之后的寫操作不會(huì)重排序到讀之前
            System.out.println(value); // 保證看到value = 42
        }
    }
}

public class VolatileBarrier {
    private volatile int value;
    public void setValue(int newValue) {
        this.value = newValue;
        // 對(duì)應(yīng)x86匯編代碼：
        // mov    %eax,0x10(%rsi)   ; 將newValue存入value的內(nèi)存地址
        // lock addl $0x0,(%rsp)    ; StoreLoad內(nèi)存屏障（mfence指令）
    }
    public int getValue() {
        // volatile讀在x86上不需要特殊指令
        // 因?yàn)閤86的內(nèi)存模型已經(jīng)保證了可見性（TSO模型）
        return value;
    }
}

public class VolatileUsage {
    // 場(chǎng)景1：狀態(tài)標(biāo)志位
    private volatile boolean shutdownRequested;
    public void shutdown() {
        shutdownRequested = true;
    }
    public void doWork() {
        while (!shutdownRequested) {
            // 執(zhí)行工作任務(wù)
        }
    }
    // 場(chǎng)景2：一次性安全發(fā)布
    private volatile Resource resource;
    public Resource getResource() {
        if (resource == null) {
            synchronized(this) {
                if (resource == null) {
                    resource = new Resource(); // 安全發(fā)布
                }
            }
        }
        return resource;
    }
}

public class SynchronizedMemory {
    private int counter = 0;
    private final Object lock = new Object();
    public void increment() {
        synchronized(lock) { 
            // monitorenter指令：
            // 1. 清空工作內(nèi)存
            // 2. 從主內(nèi)存重新加載所有共享變量
            counter++;
            // 臨界區(qū)內(nèi)的操作不會(huì)被重排序到臨界區(qū)外
        } 
        // monitorexit指令：
        // 1. 將工作內(nèi)存中的修改刷新到主內(nèi)存
        // 2. 釋放鎖
    }
    public int getCounter() {
        synchronized(lock) {
            // 獲取鎖會(huì)強(qiáng)制從主內(nèi)存重新讀取變量
            return counter;
        }
    }
}

public class HappensBeforeExample {
    private int x = 0;
    private volatile boolean v = false;
    private int y = 0;
    private final Object lock = new Object();
    public void demo() {
        // 規(guī)則1：程序次序規(guī)則
        x = 1;          // 操作A
        v = true;       // 操作B：A happens-before B
        // 規(guī)則2：volatile變量規(guī)則
        if (v) {        // 操作C：B happens-before C
            y = x;      // 操作D：C happens-before D
        }
        // 規(guī)則3：傳遞性規(guī)則
        // A happens-before B, B happens-before C, C happens-before D
        // 因此 A happens-before D
        // 規(guī)則4：管程鎖定規(guī)則
        synchronized(lock) { // 加鎖E
            x = 2;          // 操作F：E happens-before F
        } // 解鎖G：F happens-before G
        // 規(guī)則5：線程啟動(dòng)規(guī)則
        Thread t = new Thread(() -> {
            System.out.println(x); // 看到x=2
        });
        t.start(); // start() happens-before 線程中的所有操作
        // 規(guī)則6：線程終止規(guī)則
        try {
            t.join(); // 線程中的所有操作 happens-before join()返回
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 規(guī)則7：對(duì)象終結(jié)規(guī)則
        // 對(duì)象的構(gòu)造函數(shù)執(zhí)行結(jié)束 happens-before finalize()方法開始
    }
}

public class AtomicityExample {
    private int basicType = 0; // 基本類型訪問是原子的
    private long longValue = 0L; // long和double可能非原子（但現(xiàn)代JVM通常保證原子性）
    private volatile boolean flag = false; // volatile保證單個(gè)讀/寫的原子性
    // 復(fù)合操作不是原子的
    public void nonAtomicIncrement() {
        basicType++; // 不是原子操作！分解為read-modify-write三步
    }
    // 保證原子性的方式
    private final AtomicInteger atomicInt = new AtomicInteger(0);
    private final Object lock = new Object();
    private int synchronizedValue = 0;
    public void atomicOperations() {
        // 方式1：使用原子類
        atomicInt.incrementAndGet(); // 原子操作
        // 方式2：使用同步
        synchronized(lock) {
            synchronizedValue++; // 原子操作
        }
        // 方式3：使用volatile變量（僅適用于特定場(chǎng)景）
        flag = true; // 原子操作
    }
}

public class VisibilityExample {
    private int noVisibility = 0; // 無(wú)可見性保證
    private volatile boolean hasVisibility = false; // volatile保證可見性
    private int synchronizedValue = 0; // synchronized保證可見性
    private final Object lock = new Object();
    public void demonstrate() {
        // 線程1：修改數(shù)據(jù)
        new Thread(() -> {
            noVisibility = 42;
            hasVisibility = true;
            synchronized(lock) {
                synchronizedValue = 100;
            }
        }).start();
        // 線程2：讀取數(shù)據(jù)
        new Thread(() -> {
            // 可能看不到noVisibility的更新
            while (!hasVisibility) {
                // 等待hasVisibility變?yōu)閠rue
            }
            // 保證看到noVisibility = 42（因?yàn)関olatile寫happens-before volatile讀）
            synchronized(lock) {
                // 保證看到synchronizedValue = 100
            }
        }).start();
    }
}

public class OrderingExample {
    private int x = 0;
    private int y = 0;
    private volatile boolean ready = false;
    public void orderingDemo() {
        // 線程1：可能被重排序
        new Thread(() -> {
            x = 1;      // 操作1
            y = 2;      // 操作2
            ready = true; // 操作3：volatile寫，阻止重排序
        }).start();
        // 線程2
        new Thread(() -> {
            while (!ready) {
                // 等待
            }
            // 由于volatile的語(yǔ)義，這里保證看到x=1, y=2
            // 不會(huì)出現(xiàn)y=2但x=0的情況
        }).start();
    }
}

public class SafePublication {
    // 方式1：靜態(tài)初始化器（最安全）
    private static final Resource staticResource = new Resource();
    // 方式2：volatile字段
    private volatile Resource volatileResource;
    public void initVolatileResource() {
        volatileResource = new Resource(); // 安全發(fā)布
    }
    // 方式3：final字段
    private final Resource finalResource;
    public SafePublication() {
        this.finalResource = new Resource(); // 安全發(fā)布
    }
    // 方式4：正常鎖保護(hù)
    private Resource guardedResource;
    private final Object lock = new Object();
    public void initGuardedResource() {
        synchronized(lock) {
            if (guardedResource == null) {
                guardedResource = new Resource(); // 安全發(fā)布
            }
        }
    }
    // 方式5：線程安全容器
    private final Map<String, Resource> safeMap 
        = Collections.synchronizedMap(new HashMap<>());
    private final ConcurrentMap<String, Resource> concurrentMap 
        = new ConcurrentHashMap<>();
    public void addToSafeMap(String key) {
        safeMap.put(key, new Resource()); // 安全發(fā)布
    }
}

public class BrokenDCL {
    private static Resource resource; // 沒有volatile!
    public static Resource getInstance() {
        if (resource == null) {                 // 第一次檢查（無(wú)鎖）
            synchronized(BrokenDCL.class) {     // 加鎖
                if (resource == null) {         // 第二次檢查（有鎖）
                    resource = new Resource();  // 問題所在！
                    // 可能發(fā)生的重排序：
                    // 1. 分配內(nèi)存空間
                    // 2. 將引用指向內(nèi)存空間（此時(shí)resource != null）
                    // 3. 初始化對(duì)象（還未執(zhí)行）
                    // 其他線程可能拿到未完全初始化的對(duì)象！
                }
            }
        }
        return resource;
    }
}

public class CorrectDCL {
    // 使用volatile禁止重排序
    private static volatile CorrectDCL instance;
    private final int value;
    private final String name;
    private CorrectDCL() {
        this.value = 42;     // 初始化final字段
        this.name = "DCL";   // 初始化普通字段
        // 構(gòu)造函數(shù)執(zhí)行
    }
    public static CorrectDCL getInstance() {
        if (instance == null) {                     // 第一次檢查（無(wú)鎖）
            synchronized(CorrectDCL.class) {        // 加鎖
                if (instance == null) {             // 第二次檢查（有鎖）
                    instance = new CorrectDCL();    // 安全發(fā)布
                    // volatile寫插入內(nèi)存屏障，確保：
                    // 1. 所有初始化操作完成
                    // 2. 初始化結(jié)果對(duì)其他線程立即可見
                }
            }
        }
        return instance;
    }
}

public class FinalFieldExample {
    private final int finalValue; // final字段
    private int normalValue;      // 普通字段
    private volatile boolean ready = false;
    public FinalFieldExample() {
        normalValue = 1;        // 普通字段寫入（可能被重排序）
        finalValue = 42;        // final字段寫入
        // JMM在此隱式插入StoreStore內(nèi)存屏障
        // 確保final字段的初始化不會(huì)被重排序到構(gòu)造函數(shù)之外
        ready = true;           // volatile寫
    }
    public static void reader() {
        FinalFieldExample obj = new FinalFieldExample();
        // 保證看到finalValue的正確值(42)
        // 即使沒有同步，也能看到正確初始化的final字段
        int r1 = obj.finalValue;
        // 可能看到normalValue的默認(rèn)值(0)而不是1
        // 因?yàn)闆]有同步保證
        int r2 = obj.normalValue;
        // 但如果通過(guò)volatile讀看到ready=true
        // 那么也能保證看到所有字段的正確初始化值
        if (obj.ready) {
            // 保證看到finalValue=42和normalValue=1
        }
    }
}

public class CommonConcurrencyMistakes {
    // 陷阱1：認(rèn)為volatile保證原子性
    private volatile int count = 0;
    public void unsafeIncrement() {
        count++; // 不是原子操作！
    }
    // 解決方案：使用原子類或同步
    private final AtomicInteger safeCount = new AtomicInteger(0);
    private int synchronizedCount = 0;
    private final Object lock = new Object();
    public void safeIncrement() {
        safeCount.incrementAndGet(); // 方式1：原子類
        synchronized(lock) {         // 方式2：同步
            synchronizedCount++;
        }
    }
    // 陷阱2：誤用雙重檢查鎖定
    // 解決方案：使用volatile修飾實(shí)例變量
    // 陷阱3：依賴線程優(yōu)先級(jí)
    // 解決方案：不要依賴線程優(yōu)先級(jí)進(jìn)行正確性設(shè)計(jì)
    // 陷阱4：在構(gòu)造函數(shù)中啟動(dòng)線程
    public class ProblematicConstructor {
        public ProblematicConstructor() {
            new Thread(() -> {
                // 可能訪問未完全初始化的對(duì)象
            }).start();
        }
    }
}