Java并发编程中的锁优化：偏向锁、轻量级锁、自旋锁的动态切换原理

大家好，今天我们来深入探讨Java并发编程中锁优化的关键技术：偏向锁、轻量级锁以及自旋锁，以及它们之间动态切换的原理。理解这些机制对于编写高性能的并发程序至关重要。

1. 锁的概念与开销

在多线程环境下，为了保证共享资源的一致性，我们需要锁机制。Java中的锁主要通过synchronized关键字和java.util.concurrent.locks包下的Lock接口实现。synchronized是JVM层面的锁，依赖于操作系统的Mutex Lock实现，通常称为重量级锁。

重量级锁的开销主要体现在：

用户态到内核态的切换： 获取锁和释放锁需要进行用户态到内核态的切换，这涉及到上下文切换，消耗大量的CPU资源。
线程阻塞与唤醒： 当线程获取锁失败时，会被阻塞，等待锁的释放。线程的阻塞和唤醒也需要操作系统的参与，开销较高。

为了减少锁的开销，Java引入了锁升级机制，包括偏向锁、轻量级锁以及自旋锁。这些锁都是基于乐观锁的思想，尽可能避免线程阻塞。

2. 偏向锁（Biased Locking）

偏向锁的思想是：如果一个锁总是被同一个线程持有，那么该锁就偏向于这个线程，可以减少不必要的竞争。

2.1 原理

当一个线程第一次访问同步块并获取锁时，JVM会将锁对象的对象头中的Mark Word设置为偏向模式，并将线程ID记录在对象头的偏向线程ID中。以后该线程再次进入这个同步块时，不需要进行任何同步操作，只需要检查对象头的偏向线程ID是否与当前线程ID一致即可。如果一致，则认为该线程已经获得了锁，直接执行同步块中的代码。

2.2 偏向锁的获取与撤销

获取：
1. 检查锁对象头的Mark Word是否为偏向模式。
2. 如果是偏向模式，检查偏向线程ID是否为当前线程ID。
3. 如果是当前线程ID，则认为获取锁成功，直接执行同步块中的代码。
4. 如果不是当前线程ID，尝试使用CAS操作将对象头的偏向线程ID设置为当前线程ID。
  - 如果CAS操作成功，则认为获取锁成功。
  - 如果CAS操作失败，说明有其他线程正在竞争该锁，偏向锁升级为轻量级锁。
撤销：
1. 当有其他线程尝试竞争偏向锁时，偏向锁会被撤销。
2. 撤销的过程需要等到持有偏向锁的线程到达安全点（safepoint）。
3. 暂停持有偏向锁的线程，检查持有偏向锁的线程是否仍然存活。
  - 如果线程已经不存活，则将锁对象头的Mark Word重置为无锁状态。
  - 如果线程仍然存活，则将锁对象头的Mark Word重置为轻量级锁状态。

2.3 代码示例

public class BiasedLockExample {

    static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        // 启动一个线程获取锁
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 1 acquired lock");
                try {
                    Thread.sleep(2000); // 模拟持有锁一段时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1 released lock");
            }
        });

        t1.start();
        t1.join(); // 等待线程1执行完毕

        // 启动另一个线程获取锁
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 acquired lock");
            }
        });

        t2.start();
    }
}

在这个例子中，线程t1首先获取了锁，此时锁对象偏向于线程t1。当线程t2尝试获取锁时，由于锁对象已经偏向于线程t1，因此需要撤销偏向锁，并升级为轻量级锁。

2.4 偏向锁的适用场景

偏向锁适用于只有一个线程访问同步块的场景，或者多个线程交替访问同步块，但不存在竞争的场景。

2.5 关闭偏向锁

在某些高并发场景下，如果锁竞争非常激烈，偏向锁可能会频繁地被撤销，导致性能下降。此时，可以关闭偏向锁，强制使用轻量级锁。

关闭偏向锁的JVM参数是：-XX:-UseBiasedLocking

3. 轻量级锁（Lightweight Locking）

轻量级锁的思想是：在没有实际竞争的情况下，使用CAS操作尝试获取锁，避免线程阻塞。

3.1 原理

当线程尝试获取锁时，如果锁对象头的Mark Word处于无锁状态，JVM会在当前线程的栈帧中创建一个锁记录（Lock Record）空间，用于存储锁对象头的Mark Word的拷贝。然后，使用CAS操作尝试将锁对象头的Mark Word更新为指向锁记录的指针。

如果CAS操作成功，则认为该线程获取了锁，并将锁记录中的owner指针指向锁对象。
如果CAS操作失败，说明有其他线程正在竞争该锁，此时会进行自旋尝试获取锁。

3.2 轻量级锁的获取与释放

获取：
1. 检查锁对象头的Mark Word是否为无锁状态。
2. 如果是无锁状态，在当前线程的栈帧中创建一个锁记录（Lock Record）空间。
3. 将锁对象头的Mark Word拷贝到锁记录中。
4. 使用CAS操作尝试将锁对象头的Mark Word更新为指向锁记录的指针。
  - 如果CAS操作成功，则认为获取锁成功，并将锁记录中的owner指针指向锁对象。
  - 如果CAS操作失败，则进行自旋尝试获取锁。
释放：
1. 使用CAS操作尝试将锁对象头的Mark Word恢复为锁记录中保存的原始Mark Word。
  - 如果CAS操作成功，则释放锁成功。
  - 如果CAS操作失败，说明有其他线程正在竞争该锁，此时轻量级锁膨胀为重量级锁。

3.3 代码示例

public class LightweightLockExample {

    static Object lock = new Object();

    public static void main(String[] args) {
        Runnable task = () -> {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + " acquired lock");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " released lock");
            }
        };

        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

        t1.start();
        t2.start();
    }
}

在这个例子中，两个线程同时竞争锁。线程t1先获取锁，线程t2会进行自旋尝试获取锁。如果自旋一定次数后仍然无法获取锁，轻量级锁会膨胀为重量级锁。

3.4 轻量级锁的适用场景

轻量级锁适用于线程交替执行同步块，且同步块执行时间较短的场景。在这种场景下，自旋操作的开销较低，可以避免线程阻塞带来的性能损失。

4. 自旋锁（Spin Lock）

自旋锁是一种忙等待的锁，线程在获取锁失败后，不会立即阻塞，而是循环检测锁是否被释放。

4.1 原理

自旋锁的原理比较简单，就是不断地尝试获取锁，直到获取成功为止。在尝试获取锁的过程中，线程会一直占用CPU资源，进行忙等待。

4.2 自旋锁的优点与缺点

优点： 避免了线程阻塞和唤醒的开销，在高并发场景下可以提高性能。
缺点： 如果锁被其他线程长时间持有，自旋线程会一直占用CPU资源，导致CPU利用率下降。

4.3 自旋次数的控制

为了避免自旋线程长时间占用CPU资源，需要控制自旋的次数。自旋次数可以通过JVM参数-XX:PreBlockSpin来设置。默认情况下，自旋次数是10次。

4.4 自适应自旋

自适应自旋是指自旋的次数不再固定，而是根据前一次自旋的情况动态调整。如果前一次自旋成功获取了锁，则认为锁竞争不激烈，可以适当增加自旋次数；如果前一次自旋失败，则认为锁竞争激烈，可以适当减少自旋次数，甚至直接阻塞线程。

5. 锁升级的过程：偏向锁 -> 轻量级锁 -> 重量级锁

锁升级的过程是单向的，只能从偏向锁升级为轻量级锁，再升级为重量级锁，不能降级。

偏向锁 -> 轻量级锁： 当有其他线程尝试竞争偏向锁时，偏向锁会被撤销，并升级为轻量级锁。
轻量级锁 -> 重量级锁： 当线程自旋一定次数后仍然无法获取锁，轻量级锁会膨胀为重量级锁。

6. 锁消除与锁粗化

除了锁升级之外，JVM还提供了一些其他的锁优化技术，例如锁消除和锁粗化。

6.1 锁消除（Lock Elimination）

锁消除是指JVM在编译时，如果发现某些同步块中的锁实际上不会被多个线程访问，也就是说不存在锁竞争，那么JVM就会将这些锁消除，从而提高性能。

例如：

public class LockEliminationExample {

    public String concatString(String s1, String s2) {
        StringBuffer sb = new StringBuffer();
        sb.append(s1);
        sb.append(s2);
        return sb.toString();
    }

    public static void main(String[] args) {
        LockEliminationExample example = new LockEliminationExample();
        for (int i = 0; i < 10000; i++) {
            example.concatString("Hello", "World");
        }
    }
}

在这个例子中，StringBuffer是线程安全的，其append()方法是同步的。但是，在concatString()方法中，StringBuffer对象只会被一个线程访问，不存在锁竞争。因此，JVM可以消除StringBuffer对象上的锁，从而提高性能。

要启用锁消除，需要设置JVM参数-XX:+EliminateLocks。

6.2 锁粗化（Lock Coarsening）

锁粗化是指JVM在编译时，如果发现多个相邻的同步块使用了同一个锁，那么JVM会将这些同步块合并为一个更大的同步块，从而减少锁的获取和释放次数，提高性能。

例如：

public class LockCoarseningExample {

    static Object lock = new Object();

    public void insertData(String data) {
        synchronized (lock) {
            // 插入数据1
        }

        synchronized (lock) {
            // 插入数据2
        }
    }
}

在这个例子中，两个相邻的同步块使用了同一个锁lock。JVM可以将这两个同步块合并为一个更大的同步块，从而减少锁的获取和释放次数。

7. 总结：锁优化的核心在于减少锁的竞争和开销

通过偏向锁、轻量级锁、自旋锁以及锁消除、锁粗化等技术，Java JVM 尽可能地减少了锁的竞争和开销，从而提高了并发程序的性能。理解这些锁优化机制，可以帮助我们更好地编写高性能的并发程序。

锁类型	适用场景	优点	缺点
偏向锁	单线程访问同步块，或多个线程交替访问但无竞争	避免了不必要的锁竞争，减少了锁的开销	不适用于锁竞争激烈的场景，频繁撤销偏向锁会导致性能下降
轻量级锁	线程交替执行同步块，同步块执行时间较短	使用CAS操作尝试获取锁，避免线程阻塞，在高并发场景下可以提高性能	如果自旋一定次数后仍然无法获取锁，轻量级锁会膨胀为重量级锁，开销较大
自旋锁	短时间的锁等待，锁竞争不激烈	避免了线程阻塞和唤醒的开销	如果锁被其他线程长时间持有，自旋线程会一直占用CPU资源，导致CPU利用率下降，需要控制自旋次数
锁消除	同步块中的锁实际上不会被多个线程访问	消除了不必要的锁，提高了性能	需要JVM进行逃逸分析，如果分析不准确，可能会导致错误
锁粗化	多个相邻的同步块使用了同一个锁	减少了锁的获取和释放次数，提高了性能	需要JVM进行分析，如果分析不准确，可能会导致性能下降

掌握这些锁优化机制，是提升 Java 并发编程能力的关键一步。

Java并发编程中的锁优化：偏向锁、轻量级锁、自旋锁的动态切换原理

发表回复 取消回复

发表回复取消回复