Java synchronized 与锁升级机制详解

Java synchronized 与锁升级机制详解

一、synchronized 关键字概述

在 Java 中，synchronized 是一个非常重要的关键字，用于实现线程同步，保证在同一时刻只有一个线程可以访问被 synchronized 修饰的代码块或方法，从而避免多线程环境下的数据竞争和不一致问题。synchronized 可以修饰实例方法、静态方法和代码块，具体使用方式如下：

1. 修饰实例方法

public class SynchronizedExample {
    public synchronized void instanceMethod() {
        // 同步的实例方法代码
    }
}

当一个线程调用 instanceMethod() 时，会自动获取该实例对象的锁，其他线程必须等待该线程释放锁后才能调用该方法。

2. 修饰静态方法

public class SynchronizedExample {
    public static synchronized void staticMethod() {
        // 同步的静态方法代码
    }
}

静态方法属于类，而不是实例，因此当一个线程调用 staticMethod() 时，会获取该类的 Class 对象的锁，其他线程必须等待该线程释放锁后才能调用该静态方法。

3. 修饰代码块

public class SynchronizedExample {
    private final Object lock = new Object();

    public void blockMethod() {
        synchronized (lock) {
            // 同步的代码块
        }
    }
}

线程在进入 synchronized 代码块时，会获取指定对象（这里是 lock）的锁，执行完代码块后释放锁。

二、Java 锁的分类

在 Java 中，根据锁的特性和使用场景，可以将锁分为多种类型，常见的有偏向锁、轻量级锁、重量级锁等。不同类型的锁在性能和适用场景上有所不同。

1. 偏向锁

偏向锁是一种针对单线程环境的优化锁。当一个线程第一次访问同步块并获取锁时，会在对象头中记录该线程的 ID，之后该线程再次进入这个同步块时，无需进行任何同步操作，直接获取锁，这样可以减少不必要的锁竞争开销。偏向锁适用于大部分时间只有一个线程访问同步块的场景。

2. 轻量级锁

轻量级锁是为了在没有多线程竞争的情况下，减少传统重量级锁使用操作系统互斥量带来的性能开销。当多个线程交替访问同步块时，偏向锁会升级为轻量级锁。线程在进入同步块时，会尝试使用 CAS（Compare-And-Swap）操作将对象头中的 Mark Word 替换为指向锁记录的指针，如果成功则获取锁，否则表示有其他线程竞争，锁会进一步升级为重量级锁。

3. 重量级锁

重量级锁是传统的锁机制，它依赖于操作系统的互斥量（Mutex）来实现线程同步。当多个线程同时竞争锁时，轻量级锁会升级为重量级锁。重量级锁会导致线程在获取锁时进入阻塞状态，需要进行上下文切换，性能开销较大。

三、锁升级机制

Java 的锁升级机制是为了在不同的并发场景下，动态地选择最合适的锁类型，以提高性能。锁升级的过程是不可逆的，即锁只能从偏向锁升级到轻量级锁，再从轻量级锁升级到重量级锁，而不能降级。

1. 偏向锁阶段

当一个线程第一次访问同步块并获取锁时，会在对象头中记录该线程的 ID，此时对象处于偏向锁状态。后续该线程再次进入这个同步块时，无需进行任何同步操作，直接获取锁。如果有其他线程尝试访问该同步块，偏向锁会被撤销，升级为轻量级锁。

2. 轻量级锁阶段

当多个线程交替访问同步块时，偏向锁会升级为轻量级锁。线程在进入同步块时，会在栈帧中创建一个锁记录（Lock Record），并使用 CAS 操作将对象头中的 Mark Word 替换为指向锁记录的指针。如果 CAS 操作成功，则线程获取轻量级锁；如果失败，表示有其他线程竞争，锁会升级为重量级锁。

3. 重量级锁阶段

当多个线程同时竞争锁时，轻量级锁会升级为重量级锁。重量级锁依赖于操作系统的互斥量来实现线程同步，线程在获取锁时会进入阻塞状态，等待锁被释放。重量级锁的性能开销较大，但可以保证在高并发场景下的线程安全。

四、锁升级示例代码

public class LockUpgradeExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        // 线程 1
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程 1 获取到锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 线程 2
        Thread thread2 = new Thread(() -> {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lock) {
                System.out.println("线程 2 获取到锁");
            }
        });

        thread1.start();
        thread2.start();
    }
}

在上述代码中，当线程 1 先获取到锁时，对象可能处于偏向锁状态。当线程 2 尝试获取锁时，如果线程 1 还未释放锁，可能会导致锁升级为轻量级锁或重量级锁，具体取决于线程的竞争情况。