public class SynchronizedDemo {
    // 實例方法加鎖：鎖是當前對象（this）
    public synchronized void instanceMethod() {
        // 臨界區(qū)：共享資源操作（如修改實例變量）
        System.out.println(Thread.currentThread().getName() + " 執(zhí)行實例方法");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 兩個線程競爭 demo 實例的鎖，串行執(zhí)行
        new Thread(demo::instanceMethod, "線程1").start();
        new Thread(demo::instanceMethod, "線程2").start(); // 等待線程1釋放鎖
    }
}

public class SynchronizedDemo {
    // 靜態(tài)方法加鎖：鎖是 SynchronizedDemo.class
    public static synchronized void staticMethod() {
        System.out.println(Thread.currentThread().getName() + " 執(zhí)行靜態(tài)方法");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
    public static void main(String[] args) {
        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();
        // 兩個線程競爭同一把類鎖（SynchronizedDemo.class），串行執(zhí)行
        new Thread(demo1::staticMethod, "線程A").start();
        new Thread(demo2::staticMethod, "線程B").start(); // 等待線程A釋放鎖
    }
}

public class SynchronizedDemo {
    private final Object lock = new Object(); // 自定義鎖對象（推薦用 final，避免鎖對象被修改）
    private int count = 0;
    public void syncBlock() {
        // 1. 自定義對象鎖：鎖定 lock 對象
        synchronized (lock) {
            count++;
            System.out.println(Thread.currentThread().getName() + "：count=" + count);
        }
        // 2. 實例鎖（等價于修飾實例方法）
        synchronized (this) {
            // 臨界區(qū)邏輯
        }
        // 3. 類鎖（等價于修飾靜態(tài)方法）
        synchronized (SynchronizedDemo.class) {
            // 臨界區(qū)邏輯
        }
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 多線程競爭 lock 對象，count 自增線程安全
        for (int i = 0; i < 3; i++) {
            new Thread(demo::syncBlock, "線程" + i).start();
        }
    }
}

public class StockDemo {
    // 商品初始庫存：10件
    private int stock = 10;
    // 搶購方法（未加鎖）
    public void buy() {
        // 1. 檢查庫存是否充足
        if (stock > 0) {
            // 模擬網(wǎng)絡延遲（放大線程安全問題）
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            // 2. 庫存扣減
            stock--;
            // 3. 打印搶購結(jié)果
            System.out.println(Thread.currentThread().getName() + " 搶購成功！剩余庫存：" + stock);
        } else {
            System.out.println(Thread.currentThread().getName() + " 搶購失敗！庫存不足");
        }
    }
    public static void main(String[] args) {
        StockDemo stock = new StockDemo();
        // 100個用戶同時搶購（100個線程）
        for (int i = 0; i < 100; i++) {
            new Thread(stock::buy, "用戶" + (i + 1)).start();
        }
    }
}

public class StockDemo {
    private int stock = 10;
    // 方案1：修飾實例方法（鎖對象是當前 StockDemo 實例）
    public synchronized void buy() {
        if (stock > 0) {
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            stock--;
            System.out.println(Thread.currentThread().getName() + " 搶購成功！剩余庫存：" + stock);
        } else {
            System.out.println(Thread.currentThread().getName() + " 搶購失??！庫存不足");
        }
    }
    // 方案2：修飾代碼塊（鎖對象自定義，粒度更細，推薦）
    /*
    public void buy() {
        synchronized (this) {  // 鎖當前實例，也可以用自定義鎖對象（如 private final Object lock = new Object();）
            if (stock > 0) {
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                stock--;
                System.out.println(Thread.currentThread().getName() + " 搶購成功！剩余庫存：" + stock);
            } else {
                System.out.println(Thread.currentThread().getName() + " 搶購失??！庫存不足");
            }
        }
    }
    */
    public static void main(String[] args) {
        StockDemo stock = new StockDemo();
        // 100個用戶同時搶購
        for (int i = 0; i < 100; i++) {
            new Thread(stock::buy, "用戶" + (i + 1)).start();
        }
    }
}

public synchronized void methodA() {
    methodB(); // 同一線程再次獲取當前對象鎖，允許執(zhí)行
}
public synchronized void methodB() {}