Java 同步关键字 synchronized用法 、场景及避坑指南

public class SynchronizedDemo {
    // 实例方法加锁：锁是当前对象（this）
    public synchronized void instanceMethod() {
        // 临界区：共享资源操作（如修改实例变量）
        System.out.println(Thread.currentThread().getName() + " 执行实例方法");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 两个线程竞争 demo 实例的锁，串行执行
        new Thread(demo::instanceMethod, "线程1").start();
        new Thread(demo::instanceMethod, "线程2").start(); // 等待线程1释放锁
    }
}

public class SynchronizedDemo {
    // 静态方法加锁：锁是 SynchronizedDemo.class
    public static synchronized void staticMethod() {
        System.out.println(Thread.currentThread().getName() + " 执行静态方法");
        try { Thread.sleep(1000); } catch (InterruptedException e) {}
    }
    public static void main(String[] args) {
        SynchronizedDemo demo1 = new SynchronizedDemo();
        SynchronizedDemo demo2 = new SynchronizedDemo();
        // 两个线程竞争同一把类锁（SynchronizedDemo.class），串行执行
        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) {
            // 临界区逻辑
        }
        // 3. 类锁（等价于修饰静态方法）
        synchronized (SynchronizedDemo.class) {
            // 临界区逻辑
        }
    }
    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) {
            // 模拟网络延迟（放大线程安全问题）
            try { Thread.sleep(10); } catch (InterruptedException e) {}
            // 2. 库存扣减
            stock--;
            // 3. 打印抢购结果
            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(); // 同一线程再次获取当前对象锁，允许执行
}
public synchronized void methodB() {}