synchronized 详解

/**
 * 飞翔科技 - 银行账户并发转账安全问题演示
 * 
 * 场景：账号 10001，初始余额 8888.88 元
 *       大翔到 ATM 取款，小崔用网银转账同时发生
 */
public class BankTransferDemo {

    // === 不安全版本：无同步保护 ===
    static class UnsafeAccount {
        private String owner;
        private float balance;  // 余额

        public UnsafeAccount(String owner, float balance) {
            this.owner = owner;
            this.balance = balance;
        }

        // ✗ 没有 synchronized — 多线程并发调用会丢失更新
        public void withdraw(float amount) {
            if (balance >= amount) {
                // 模拟网络延迟
                try { Thread.sleep(10); } catch (InterruptedException e) { }
                balance -= amount;
                System.out.printf("[%s] 取款 %.2f 成功, 余额: %.2f\n",
                        Thread.currentThread().getName(), amount, balance);
            } else {
                System.out.printf("[%s] 余额不足! 当前余额: %.2f\n",
                        Thread.currentThread().getName(), balance);
            }
        }

        public float getBalance() { return balance; }
    }

    // === 安全版本：synchronized 实例方法 ===
    static class SafeAccount {
        private String owner;
        private float balance;

        public SafeAccount(String owner, float balance) {
            this.owner = owner;
            this.balance = balance;
        }

        // ✓ synchronized 实例方法 — 锁是当前对象 this
        public synchronized void withdraw(float amount) {
            if (balance >= amount) {
                try { Thread.sleep(10); } catch (InterruptedException e) { }
                balance -= amount;
                System.out.printf("[%s] 取款 %.2f 成功, 余额: %.2f\n",
                        Thread.currentThread().getName(), amount, balance);
            } else {
                System.out.printf("[%s] 余额不足! 当前余额: %.2f\n",
                        Thread.currentThread().getName(), balance);
            }
        }

        public synchronized float getBalance() { return balance; }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("========== 飞翔科技银行账户安全测试 ==========\n");

        // === 测试不安全版本 ===
        System.out.println("--- 不安全版本（无 synchronized）---");
        UnsafeAccount unsafeAcc = new UnsafeAccount("大翔工资卡(10001)", 8888.88f);
        Thread u1 = new Thread(() -> {
            for (int i = 0; i < 8; i++) unsafeAcc.withdraw(555.55f);
        }, "大翔-ATM");
        Thread u2 = new Thread(() -> {
            for (int i = 0; i < 8; i++) unsafeAcc.withdraw(555.55f);
        }, "小崔-网银");
        u1.start(); u2.start();
        u1.join(); u2.join();
        System.out.printf(">>> 不安全版本最终余额: %.2f (期望: %.2f)\n\n",
                unsafeAcc.getBalance(), 8888.88f - 16 * 555.55f);

        // === 测试安全版本 ===
        System.out.println("--- 安全版本（synchronized 方法）---");
        SafeAccount safeAcc = new SafeAccount("大翔工资卡(10001)", 8888.88f);
        Thread s1 = new Thread(() -> {
            for (int i = 0; i < 8; i++) safeAcc.withdraw(555.55f);
        }, "大翔-ATM");
        Thread s2 = new Thread(() -> {
            for (int i = 0; i < 8; i++) safeAcc.withdraw(555.55f);
        }, "小崔-网银");
        s1.start(); s2.start();
        s1.join(); s2.join();
        System.out.printf(">>> 安全版本最终余额: %.2f (期望: %.2f)\n",
                safeAcc.getBalance(), 8888.88f - 16 * 555.55f);
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * 飞翔科技 - 火车票售票系统 synchronized 代码块应用
 * 
 * 场景：50 张票，单价 188.88 元，3 个窗口并发售票
 *       使用 synchronized 代码块精确定义临界区，锁外执行耗时操作
 */
public class TicketSystemDemo {

    static class TicketCounter {
        private int remaining;
        private final float ticketPrice = 188.88f;

        public TicketCounter(int total) {
            this.remaining = total;
        }

        // 专用锁对象 — 比锁 this 更安全（避免外部代码误用 this 锁）
        private final Object ticketLock = new Object();

        /**
         * 售票方法 — 使用 synchronized 代码块
         * 只有操作共享变量 remaining 的代码在锁内
         * 日志打印、票据生成等耗时操作在锁外执行
         */
        public int sellTicket(String windowName, int requestCount) {
            // === 非临界区：日志、校验等不需要同步 ===
            System.out.printf("[%s] 申请购买 %d 张票 (单价 %.2f)...\n",
                    windowName, requestCount, ticketPrice);

            int actualSold;
            float totalPrice;

            // === 临界区：只锁住操作共享变量的代码 ===
            synchronized (ticketLock) {
                if (remaining >= requestCount) {
                    remaining -= requestCount;
                    actualSold = requestCount;
                    totalPrice = actualSold * ticketPrice;
                    System.out.printf("[%s] ✓ 成功购得 %d 张，小计 %.2f 元，剩余 %d 张\n",
                            windowName, actualSold, totalPrice, remaining);
                } else if (remaining > 0) {
                    actualSold = remaining;
                    totalPrice = actualSold * ticketPrice;
                    remaining = 0;
                    System.out.printf("[%s] ⚠ 票不足！仅购得 %d 张，小计 %.2f 元，已售罄\n",
                            windowName, actualSold, totalPrice);
                } else {
                    actualSold = 0;
                    totalPrice = 0;
                    System.out.printf("[%s] ✗ 票已售罄！\n", windowName);
                }
            }

            // === 非临界区：打印票据（耗时操作放锁外） ===
            if (actualSold > 0) {
                try { Thread.sleep(30); } catch (InterruptedException e) { }
                System.out.printf("[%s] 票据打印完成: %d 张，合计 %.2f 元\n",
                        windowName, actualSold, totalPrice);
            }

            return actualSold;
        }

        public int getRemaining() {
            synchronized (ticketLock) {
                return remaining;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TicketCounter counter = new TicketCounter(50);
        List<String> salesLog = new ArrayList<>();

        // 窗口1：大翔 — 每次买 3 张
        Thread w1 = new Thread(() -> {
            int total = 0;
            for (int i = 0; i < 8; i++) {
                total += counter.sellTicket("窗口1-大翔(工号10001)", 3);
                try { Thread.sleep(15); } catch (InterruptedException e) { }
            }
            salesLog.add("窗口1-大翔 共购: " + total + " 张");
        });

        // 窗口2：白歌 — 每次买 5 张
        Thread w2 = new Thread(() -> {
            int total = 0;
            for (int i = 0; i < 6; i++) {
                total += counter.sellTicket("窗口2-白歌(工号10002)", 5);
                try { Thread.sleep(15); } catch (InterruptedException e) { }
            }
            salesLog.add("窗口2-白歌 共购: " + total + " 张");
        });

        // 窗口3：小崔 — 每次买 2 张
        Thread w3 = new Thread(() -> {
            int total = 0;
            for (int i = 0; i < 10; i++) {
                total += counter.sellTicket("窗口3-小崔(工号10003)", 2);
                try { Thread.sleep(15); } catch (InterruptedException e) { }
            }
            salesLog.add("窗口3-小崔 共购: " + total + " 张");
        });

        w1.start(); w2.start(); w3.start();
        w1.join(); w2.join(); w3.join();

        System.out.println("\n========== 售票汇总 ==========");
        for (String log : salesLog) System.out.println(log);
        System.out.printf("剩余票数: %d\n", counter.getRemaining());
    }
}

/**
 * 飞翔科技 - synchronized 可重入性演示
 */
public class ReentrantDemo {

    // 所有 synchronized 实例方法共享同一把 this 锁
    public synchronized void methodA() {
        System.out.println(Thread.currentThread().getName() + " 进入 methodA");
        // methodA 内部调用 methodB — 同一线程，同一把锁，不会死锁
        methodB();  // ✓ 可重入！
    }

    public synchronized void methodB() {
        System.out.println(Thread.currentThread().getName() + " 进入 methodB");
        methodC();
    }

    public synchronized void methodC() {
        System.out.println(Thread.currentThread().getName() + " 进入 methodC");
    }

    public static void main(String[] args) {
        ReentrantDemo demo = new ReentrantDemo();
        // 线程 10001 号大翔多次进入锁
        new Thread(() -> demo.methodA(), "大翔-10001").start();
    }
}

/**
 * 飞翔科技 - 类锁与实例锁互不干扰演示
 */
public class ClassLockVsInstanceLock {

    // 实例锁 — 锁定 this
    public synchronized void instanceMethod() {
        System.out.println(Thread.currentThread().getName() + " 获得实例锁");
        try { Thread.sleep(2000); } catch (InterruptedException e) { }
        System.out.println(Thread.currentThread().getName() + " 释放实例锁");
    }

    // 类锁 — 锁定 ClassLockVsInstanceLock.class
    public static synchronized void classMethod() {
        System.out.println(Thread.currentThread().getName() + " 获得类锁");
        try { Thread.sleep(2000); } catch (InterruptedException e) { }
        System.out.println(Thread.currentThread().getName() + " 释放类锁");
    }

    public static void main(String[] args) {
        ClassLockVsInstanceLock obj = new ClassLockVsInstanceLock();

        // t1 获取实例锁，t2 获取类锁 — 互不干扰，可同时执行
        Thread t1 = new Thread(() -> obj.instanceMethod(), "大翔-10001");
        Thread t2 = new Thread(() -> ClassLockVsInstanceLock.classMethod(), "白歌-10002");

        long start = System.currentTimeMillis();
        t1.start(); t2.start();
        try { t1.join(); t2.join(); } catch (InterruptedException e) { }
        long elapsed = System.currentTimeMillis() - start;
        System.out.printf("总耗时: %d ms (如果互斥则需 4000ms，并行则约 2000ms)\n", elapsed);
    }
}

/**
 * 飞翔科技 - JDK 8 偏向锁延迟验证
 * 运行时添加 JVM 参数查看锁状态：
 *   -XX:+PrintGCDetails -XX:+PrintFlagsFinal
 *   -XX:BiasedLockingStartupDelay=0  关闭延迟
 */
public class BiasedLockDemo {

    public static void main(String[] args) throws InterruptedException {
        // 延迟 6 秒后创建对象 — 此时偏向锁已激活
        System.out.println("等待偏向锁激活...");
        Thread.sleep(6000);

        Object lock = new Object();
        System.out.println("创建锁对象: " + lock);

        // 查看对象头 — 可配合 jol-core 库查看 Mark Word
        // System.out.println(ClassLayout.parseInstance(lock).toPrintable());

        long start = System.currentTimeMillis();
        // 线程 10001 号大翔反复进入同步块
        for (int i = 0; i < 100000000; i++) {
            synchronized (lock) {
                // 偏向锁模式下，几乎无开销
            }
        }
        long elapsed = System.currentTimeMillis() - start;
        System.out.printf("100,000,000 次 synchronized 执行耗时: %d ms\n", elapsed);
    }
}

// ✗ 错误：String 常量池中的对象是全局共享的
synchronized ("飞翔科技") {  // 所有用 "飞翔科技" 加锁的代码都在抢同一把锁！
    // ...
}

// ✓ 正确：使用专用 Object 或 final 成员变量
private final Object lock = new Object();
synchronized (lock) { ... }

// ✗ 错误：Integer 在 -128~127 范围使用缓存，不同地方可能拿到同一对象
synchronized (new Integer(count)) { ... }

// ✗ 错误：锁对象被重新赋值，锁失效
private Object lock = new Object();
public void method() {
    synchronized (lock) {
        lock = new Object();  // 锁对象变了！其他线程可能拿到新对象
    }
}

// ✓ 正确：锁对象使用 final 修饰
private final Object lock = new Object();

// ✗ 错误：run() 加了 synchronized，但每个线程是不同 Runnable 实例，锁不住
class MyTask implements Runnable {
    public synchronized void run() { ... }  // 锁的是不同实例，无效！
}

// ✓ 正确：共享同一个锁对象
public void run() {
    synchronized (sharedLock) { ... }
}

// synchronized 在异常时自动释放锁 — 这是正确的行为
// 但如果异常后的状态不一致（如转账扣了A的钱但抛异常没加给B），需要处理
public synchronized void transfer(Account from, Account to, float amount) {
    from.withdraw(amount);           // 扣款成功
    // 如果这里抛异常...
    to.deposit(amount);              // 未执行！钱丢了！
}
// ✓ 正确：记录操作日志或回滚，确保数据一致性

// ✓ 正确：只在操作共享数据时加锁，耗时的 IO/网络操作放锁外
public void processOrder(int orderId) {
    // 锁外：查询数据库、网络请求等耗时操作
    Order order = queryOrderFromDB(orderId);

    synchronized (inventoryLock) {
        // 锁内：只操作共享的商品库存
        inventory.decrease(order.getProductId(), order.getQuantity());
    }

    // 锁外：发送通知、打印小票等
    sendNotification(order.getUserId());
}