深入理解Java中的偏向锁、轻量级锁与重量级锁

深入理解Java中的偏向锁、轻量级锁与重量级锁

在Java的多线程编程中，锁（Lock）是确保线程安全和协调线程执行的核心机制。为了优化锁的性能，Java虚拟机（JVM）引入了多种锁优化技术，其中最重要的包括偏向锁（Biased Locking）、轻量级锁（Lightweight Locking）和重量级锁（Heavyweight Locking）。本文将深入探讨这三种锁的原理、工作机制、优缺点及其在实际开发中的应用场景。

目录

1. 锁的基础知识
2. 偏向锁（Biased Locking）
   • 原理与工作机制
   • 优缺点
   • 启用与禁用偏向锁
   • 示例
3. 轻量级锁（Lightweight Locking）
   • 原理与工作机制
   • 优缺点
   • 示例
4. 重量级锁（Heavyweight Locking）
   • 原理与工作机制
   • 优缺点
   • 示例
5. 锁优化的转变过程
6. 实际应用中的选择与优化
7. 总结

---

锁的基础知识

在多线程环境中，当多个线程尝试访问共享资源时，锁用于控制对资源的访问，确保数据的一致性和完整性。Java提供了多种锁机制，其中最常用的是基于synchronized关键字的内置锁。为了提高锁的性能，JVM采用了多种优化技术，包括偏向锁、轻量级锁和重量级锁。

内置锁的基本行为

• 加锁与解锁：当一个线程进入一个synchronized块或方法时，它会尝试获取相应对象的监视器锁。如果锁被其他线程持有，当前线程会被阻塞，直到锁被释放。
• 不可重入性：Java的内置锁是可重入锁，即同一个线程可以多次获取同一把锁而不会导致死锁。

锁的性能问题

锁的获取和释放是有开销的，尤其是在高并发的情况下，频繁的上下文切换和线程阻塞会严重影响性能。因此，JVM通过引入偏向锁、轻量级锁和重量级锁来优化锁的性能，减少不必要的同步开销。

---

偏向锁（Biased Locking）

原理与工作机制

偏向锁是一种锁优化技术，旨在减少在单线程环境下锁的获取与释放开销。其核心思想是：假设同一把锁大多数情况下只被一个线程频繁地获取和释放，那么可以将这把锁偏向于该线程，当该线程再次请求锁时，无需再进行同步操作。

工作流程

1. 初始状态：对象处于无锁状态。
2. 第一次获取锁：
   • 当一个线程首次获取锁时，锁会被标记为偏向于该线程。
   • 锁的Mark Word中存储了偏向线程的ID。
3. 偏向线程再次获取锁：
   • 如果偏向线程再次请求锁，JVM无需执行任何同步操作，直接进入锁定状态。
4. 其他线程竞争锁：
   • 如果另一个线程尝试获取已经偏向于某个线程的锁，JVM会撤销偏向锁，将其升级为轻量级锁或重量级锁。
   • 偏向锁的撤销需要CAS操作和锁记录的修改，具备一定的开销。

优缺点

优点：

• 减少同步开销：在大多数情况下，锁只被一个线程持有，偏向锁可以显著减少获取锁的开销。
• 提升性能：尤其在单线程环境或锁竞争不激烈的场景下，偏向锁能够提升程序性能。

缺点：

• 不适用于高竞争场景：一旦多个线程竞争同一把锁，偏向锁需要撤销并升级为其他锁，可能带来额外的性能开销。
• 增加内存开销：每个对象的Mark Word中需要存储偏向线程的ID。

启用与禁用偏向锁

在Java 6及以上版本，偏向锁是默认启用的。可以通过JVM参数来控制偏向锁的行为：

• 禁用偏向锁：

  -XX:-UseBiasedLocking
  

• 延迟启用偏向锁（默认为400ms）：

  -XX:BiasedLockingStartupDelay=0
  

示例

以下示例展示了偏向锁的基本行为：

public class BiasedLockingExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 第一次获取锁，偏向于主线程
        synchronized (lock) {
            System.out.println("主线程获取锁，偏向锁被启用");
        }

        Thread.sleep(5000); // 等待其他线程启动

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("子线程获取锁");
            }
        });

        thread.start();
        thread.join();
    }
}

输出：

主线程获取锁，偏向锁被启用
子线程获取锁

在这个示例中，主线程首次获取锁时，锁会偏向于主线程。之后，子线程尝试获取锁时，偏向锁会被撤销，并升级为轻量级锁或重量级锁，以允许子线程获取锁。

---

轻量级锁（Lightweight Locking）

原理与工作机制

轻量级锁是一种优化机制，旨在减少在没有锁竞争时获取和释放锁的开销。其核心思想是：当多个线程不竞争同一把锁时，锁的获取与释放可以通过无阻塞的CAS（Compare-And-Swap）操作完成，而无需进行上下文切换。

工作流程

1. 尝试获取锁：
   • 线程尝试通过CAS操作将对象的Mark Word从无锁状态更新为指向当前线程的锁记录。
2. 获取成功：
   • 如果CAS操作成功，线程持有锁，进入锁定状态。
3. 获取失败：
   • 如果CAS操作失败，表示有其他线程持有锁，线程进入BLOCKED状态，尝试获取重量级锁。
4. 释放锁：
   • 线程释放锁时，通过CAS操作将Mark Word恢复为无锁状态。

优缺点

优点：

• 减少同步开销：在无锁竞争的情况下，通过CAS操作快速获取锁，避免了重量级锁的上下文切换开销。
• 适用于低竞争场景：在多个线程不频繁竞争同一把锁时，轻量级锁能显著提升性能。

缺点：

• 有限的竞争处理能力：一旦多个线程频繁竞争锁，轻量级锁可能无法有效处理，锁会升级为重量级锁。
• 依赖CAS操作：CAS操作可能导致ABA问题（虽然在JVM中已通过其他机制处理），并且在高并发情况下可能会导致性能下降。

示例

以下示例展示了轻量级锁的基本行为：

public class LightweightLockingExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 第一个线程获取锁，轻量级锁被启用
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1获取锁");
                try {
                    Thread.sleep(1000); // 保持锁一段时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1释放锁");
            }
        });

        // 第二个线程尝试获取锁
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2获取锁");
            }
        });

        thread1.start();
        Thread.sleep(100); // 确保线程1先获取锁
        thread2.start();

        thread1.join();
        thread2.join();
    }
}

输出：

线程1获取锁
线程1释放锁
线程2获取锁

在这个示例中，线程1首先获取锁，使用轻量级锁进行同步。线程2在等待线程1释放锁时，会尝试获取锁。由于锁在释放后不再有竞争，线程2能够顺利获取锁，继续执行。

---

重量级锁（Heavyweight Locking）

原理与工作机制

重量级锁是最基本的锁机制，通常在高并发或锁竞争激烈的情况下使用。当偏向锁和轻量级锁无法满足需求时，锁会升级为重量级锁。重量级锁依赖于操作系统的互斥量（Mutex）来管理锁的获取与释放。

工作流程

1. 获取锁：
   • 线程尝试通过CAS操作获取锁，如果失败，锁会升级为重量级锁。
   • JVM会将线程加入到锁的等待队列中，操作系统负责调度线程。
2. 阻塞与唤醒：
   • 无法获取锁的线程会被阻塞，进入BLOCKED状态。
   • 当持有锁的线程释放锁时，操作系统会唤醒等待队列中的线程之一。
3. 释放锁：
   • 线程释放锁后，锁从重量级锁状态恢复为无锁状态。

优缺点

优点：

• 处理高竞争：能够有效处理多个线程频繁竞争同一把锁的情况。
• 确保锁的独占性：通过操作系统的互斥量机制，确保锁的严格独占。

缺点：

• 高开销：涉及到操作系统的线程调度和上下文切换，开销较大。
• 性能瓶颈：在高并发场景下，频繁的锁获取与释放会严重影响程序性能。

示例

以下示例展示了重量级锁的基本行为：

public class HeavyweightLockingExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 创建多个线程竞争同一把锁
        for (int i = 1; i <= 5; i++) {
            final int threadNum = i;
            Thread thread = new Thread(() -> {
                synchronized (lock) {
                    System.out.println("线程" + threadNum + "获取锁");
                    try {
                        Thread.sleep(1000); // 保持锁一段时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程" + threadNum + "释放锁");
                }
            });
            thread.start();
        }
    }
}

输出（顺序可能略有不同）：

线程1获取锁
线程1释放锁
线程2获取锁
线程2释放锁
线程3获取锁
线程3释放锁
线程4获取锁
线程4释放锁
线程5获取锁
线程5释放锁

在这个示例中，多个线程同时尝试获取同一把锁。由于锁竞争激烈，锁会升级为重量级锁，导致线程被阻塞和唤醒的开销显著增加。

---

锁优化的转变过程

JVM在运行过程中，根据锁的竞争情况动态调整锁的类型，以实现最佳的性能优化。这一过程如下：

1. 无锁状态（Unlocked）：

   • 对象的Mark Word表示无锁状态。
   • 线程尝试获取锁时，如果成功，锁被偏向于当前线程，进入偏向锁状态。

2. 偏向锁状态（Biased Locking）：

   • 对象的Mark Word存储偏向线程的ID。
   • 偏向线程再次获取锁时，无需进行同步操作，直接进入锁定状态。
   • 如果其他线程尝试获取锁，偏向锁会被撤销，进入轻量级锁状态。

3. 轻量级锁状态（Lightweight Locking）：

   • 通过CAS操作尝试获取锁。
   • 如果成功，锁记录保存在线程的栈中，Mark Word指向锁记录。
   • 如果有竞争，锁会升级为重量级锁。

4. 重量级锁状态（Heavyweight Locking）：

   • 使用操作系统的互斥量管理锁。
   • 线程被阻塞，直到锁被释放。
   • 解锁后，锁恢复为无锁状态或重新进行偏向锁优化。

锁的升级路径

无锁状态 → 偏向锁 → 轻量级锁 → 重量级锁

示例

以下示例展示了锁从偏向锁升级到重量级锁的过程：

public class LockUpgradeExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();

        // 首先一个线程获取锁，偏向锁被启用
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1获取锁");
                try {
                    Thread.sleep(2000); // 保持锁一段时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1释放锁");
            }
        });

        // 另一个线程尝试获取同一把锁，导致锁升级
        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2获取锁");
            }
        });

        thread1.start();
        Thread.sleep(500); // 确保线程1先获取锁
        thread2.start();

        thread1.join();
        thread2.join();
    }
}

输出：

线程1获取锁
线程1释放锁
线程2获取锁

在这个示例中，线程1首先获取锁，偏向锁被启用。线程2尝试获取同一把锁时，偏向锁被撤销，锁升级为重量级锁，使得线程2能够获取锁。

---

实际应用中的选择与优化

理解偏向锁、轻量级锁与重量级锁的工作原理，有助于在实际开发中做出合适的同步策略选择和性能优化。

1. 减少锁的持有时间

尽量缩小synchronized块的范围，减少锁的持有时间，降低锁竞争的概率。

// 不推荐
synchronized(lock) {
    // 大量处理逻辑
}

// 推荐
synchronized(lock) {
    // 只处理必要的同步操作
}
// 大量处理逻辑

2. 使用更细粒度的锁

将一个大的锁拆分为多个小的锁，降低锁的竞争程度。

// 不推荐：一个锁保护多个资源
synchronized(lock) {
    // 资源A的操作
    // 资源B的操作
}

// 推荐：分别使用不同的锁保护不同的资源
synchronized(lockA) {
    // 资源A的操作
}
synchronized(lockB) {
    // 资源B的操作
}

3. 利用无锁数据结构

在可能的情况下，使用Java并发包（java.util.concurrent）提供的无锁或高效锁的数据结构，如ConcurrentHashMap、CopyOnWriteArrayList等，避免显式的synchronized同步。

// 使用 ConcurrentHashMap 代替 HashMap + synchronized
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put("key", "value");

4. 合理配置JVM参数

根据应用的特性和需求，调整JVM的锁优化参数，如偏向锁的启用与禁用、偏向锁的延迟启动时间等。

# 禁用偏向锁
-XX:-UseBiasedLocking

# 设置偏向锁启动延迟为0，立即启用
-XX:BiasedLockingStartupDelay=0

5. 避免过度同步

不要对不必要的代码块进行同步，避免引入不必要的锁竞争和性能开销。

// 不推荐：过度同步
public void update() {
    synchronized(lock) {
        // 不需要同步的操作
        this.value = newValue;
    }
}

// 推荐：只同步需要保护的部分
public void update() {
    this.value = newValue; // 不需要同步
}

---

总结

Java中的偏向锁、轻量级锁与重量级锁构成了一套复杂而高效的锁优化机制，旨在在不同的并发场景下提供最佳的性能表现：

• 偏向锁：适用于锁主要被一个线程持有的场景，减少了锁的获取与释放开销。
• 轻量级锁：适用于锁被少量线程竞争的场景，通过CAS操作实现快速的锁获取。
• 重量级锁：适用于锁被高频率、多线程竞争的场景，确保锁的独占性。

通过合理理解和应用这些锁机制，结合良好的并发编程实践，可以显著提升Java应用程序的性能和响应性。同时，随着Java版本的不断演进，锁的优化机制也在持续改进，开发者应及时关注最新的JVM优化技术，以充分利用其带来的性能优势。

希望本文能够帮助你深入理解Java中的偏向锁、轻量级锁与重量级锁，并在实际开发中灵活应用。如有任何问题或需要进一步探讨，欢迎在评论区留言交流！