Java synchronized关键字从入门到原理解析

public class Counter {
    private int count = 0;
    public void increment() {
        count++; // 不是原子操作！
    }
    public int getCount() {
        return count;
    }
}
// 测试代码
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终结果: " + counter.getCount()); // 期望20000，实际小于20000
    }
}

public class SyncMethodDemo {
    private int count = 0;
    // synchronized修饰实例方法，锁是当前对象this
    public synchronized void increment() {
        count++;
    }
}

线程A ──> obj1.increment() ──> 获取obj1锁 ──> 执行
线程B ──> obj1.increment() ──> 等待obj1锁
线程C ──> obj2.increment() ──> 获取obj2锁 ──> 执行（与A不冲突）

public class SyncStaticDemo {
    private static int count = 0;
    // synchronized修饰静态方法，锁是当前类的Class对象
    public static synchronized void increment() {
        count++;
    }
}

public class SyncBlockDemo {
    private Object lock = new Object();
    private int count = 0;
    public void increment() {
        // 同步代码块，锁是指定的lock对象
        synchronized (lock) {
            count++;
        }
    }
    public void decrement() {
        // 也可以锁this
        synchronized (this) {
            count--;
        }
    }
}

synchronized (SyncBlockDemo.class) {
    // 这是类锁
}

public class ReentrantDemo {
    public synchronized void methodA() {
        System.out.println("进入methodA");
        methodB(); // 直接调用，不会死锁
    }
    public synchronized void methodB() {
        System.out.println("进入methodB");
    }
}

public class SyncCodeBlock {
    public void doSomething() {
        synchronized (this) {
            System.out.println("hello");
        }
    }
}

 3: monitorenter      // 进入同步块，获取监视器锁
 4: getstatic         // 调用System.out
 7: ldc               // 加载字符串
 9: invokevirtual     // 调用println
12: aload_1
13: monitorexit       // 退出同步块，释放监视器锁
14: goto 22           // 正常结束跳转
17: astore_2          // 异常处理开始
18: aload_1
19: monitorexit       // 异常时也释放锁
20: aload_2
21: athrow            // 抛出异常
22: return

public synchronized void syncMethod() {
    System.out.println("hello");
}

public synchronized void syncMethod();
  descriptor: ()V
  flags: ACC_PUBLIC, ACC_SYNCHRONIZED  // 注意这个标志
  Code:
   0: getstatic     #2
   3: ldc           #3
   5: invokevirtual #4
   8: return

                  ┌─────────────────────┐
                  │      Owner          │ ← 当前持有锁的线程
                  ├─────────────────────┤
                  │     EntryList       │ ← 等待获取锁的线程队列
                  ├─────────────────────┤
                  │     WaitSet         │ ← 调用了wait()的线程队列
                  └─────────────────────┘

public class BiasedLockDemo {
    private static List<Integer> list = new Vector<>(); // Vector的方法都是同步的
    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            list.add(i); // 同一线程反复获取锁
        }
    }
}

                   偏向锁
                     │
                     │ 有其他线程尝试获取
                     ↓
                 轻量级锁
                     │
                     │ 有真实竞争
                     ↓
                 重量级锁

public class VolatileDemo {
    private volatile boolean flag = true; // 只作为状态标志
    public void stop() {
        flag = false; // 简单写操作
    }
    public void run() {
        while (flag) {
            // 执行任务
        }
    }
}

ReentrantLock lock = new ReentrantLock(true); // 公平锁
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();
// 标准使用模式
lock.lock();
try {
    // 临界区代码
    while (条件不满足) {
        notEmpty.await(); // 等待
    }
    // 执行操作
    notFull.signal();
} finally {
    lock.unlock(); // 必须释放
}

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();
    private EagerSingleton() {}
    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

public class LazySingleton {
    private static LazySingleton instance;
    private LazySingleton() {}
    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

public class DCLSingleton {
    // volatile保证可见性和禁止重排序
    private static volatile DCLSingleton instance;
    private DCLSingleton() {}
    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}