浅谈偏向锁、轻量级锁、重量级锁

在多线程编程中，锁是一个关键概念，用于控制对共享资源的访问。为了提高多线程程序的性能和效率，Java引入了偏向锁、轻量级锁和重量级锁等不同级别的锁机制。本文将深入讨论这些锁的概念、工作原理以及在实际应用中的使用场景。

第一部分：偏向锁

1. 什么是偏向锁？

偏向锁是为了解决单线程情况下对锁的性能影响而引入的概念。它的核心思想是：当一个线程第一次访问一个同步代码块时，它会尝试获取偏向锁，如果成功获取，后续的访问都无需竞争，直接获得锁。只有在其他线程尝试获取锁时，偏向锁才会升级为轻量级锁或重量级锁。

2. 偏向锁的工作原理

当线程进入同步块时，偏向锁的标记位被设置为线程的ID。

如果另一个线程尝试访问这个同步块，它会检查偏向锁的标记位，发现已经被其他线程占用，于是尝试获取锁。

如果锁获取失败，线程会进行CAS（Compare and Swap）操作，将偏向锁升级为轻量级锁。

3. 使用示例

下面是一个简单的Java示例，演示了偏向锁的使用：

Copy code
public class BiasedLockExample {

    public synchronized void performOperation() {
        // 同步代码块
    }

    public static void main(String[] args) {
        BiasedLockExample obj = new BiasedLockExample();

        // 多个线程竞争锁
        for (int i = 0; i < 5; i++) {
            new Thread(obj::performOperation).start();
        }
    }
}

在上述示例中，多个线程尝试进入performOperation方法，但由于偏向锁的存在，只有第一个线程获得了锁，后续线程无需竞争。

第二部分：轻量级锁

4. 什么是轻量级锁？

轻量级锁是为了解决多个线程同时访问同步代码块时的性能问题而引入的。它的特点是采用CAS操作来竞争锁，如果竞争失败，线程将膨胀为重量级锁。轻量级锁适用于线程竞争不激烈的情况。

5. 轻量级锁的工作原理

当线程第一次进入同步块时，JVM会将对象头中的锁标记位设置为指向线程的锁记录（Lock Record）。

如果有其他线程尝试进入同步块，它们会尝试使用CAS操作竞争锁记录。如果竞争成功，线程会进入同步块。否则，锁膨胀为重量级锁。

6. 使用示例

下面是一个简单的Java示例，演示了轻量级锁的使用：

Copy code
public class LightweightLockExample {

    private volatile int count = 0;

    public void increment() {
        synchronized (this) {
            count++;
        }
    }

    public static void main(String[] args) {
        LightweightLockExample obj = new LightweightLockExample();

        // 多个线程竞争锁
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100000; j++) {
                    obj.increment();
                }
            }).start();
        }

        // 等待所有线程完成
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Count: " + obj.count);
    }
}

在上述示例中，多个线程竞争对count进行递增操作，但由于轻量级锁的存在，性能相对较高。

第三部分：重量级锁

7. 什么是重量级锁？

重量级锁是最传统的锁形式，它适用于多个线程竞争同步代码块的情况。当多个线程同时访问同步块时，它们将会进入阻塞状态，直到获取到锁为止。

8. 重量级锁的工作原理

当线程尝试进入同步块时，如果发现锁已经被其他线程占用，它会进入阻塞状态，等待锁的释放。

当锁被释放时，等待的线程会通过竞争获取锁，只有一个线程成功。

其他等待的线程会继续阻塞，直到获取到锁为止。

9. 使用示例

下面是一个简单的Java示例，演示了重量级锁的使用：

Copy code
public class HeavyweightLockExample {

    private static int counter = 0;
    private static final Object lock = new Object();

    public static void main(String[] args) {
        // 多个线程竞争锁
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                synchronized (lock) {
                    for (int j = 0; j < 100000; j++) {
                        counter++;
                    }
                }
            }).start();
        }

        // 等待所有线程完成
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Counter: " + counter);
    }
}