Java中Synchronized锁升级机制详解

最新推荐文章于 2025-04-07 11:40:07 发布

置顶小电玩

最新推荐文章于 2025-04-07 11:40:07 发布

阅读量2.3k

点赞数 20

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_49841284/article/details/140536745

版权

Java中Synchronized锁升级机制详解

在Java中，synchronized关键字是实现线程同步的一种方式，但它的性能受到锁的开销影响。为了减少锁带来的性能损失，Java虚拟机(JVM)设计了一套锁升级机制，使得锁可以从无锁状态逐渐升级至重量级锁。我们将会通过代码示例，来探索这个升级过程的细节。锁升级机制包括以下阶段：

无锁状态：
- 在对象创建之初，它处于无锁状态，没有任何锁标志位被设置。
- 这个状态下，对象可以被任何线程自由访问，因为没有线程试图获取锁。
偏向锁状态：
- 当第一个线程尝试获取synchronized锁时，对象会进入偏向锁状态。
- 偏向锁记录了当前线程的ID，允许该线程无需额外的同步检查即可访问对象。
- 如果线程再次访问同一个对象，它可以直接访问，而不会经历重新加锁的过程。
  (如果当前线程再次访问同一个对象，它确实可以直接访问，这是因为偏向锁已经“偏向”于当前线程，对象头中保存了当前线程的ID，所以无需再次进行锁获取的检查。但是，这并不意味着其他线程可以随意访问或获取锁。),(偏向锁是为了减少单一线程访问同一对象的开销，但在多线程竞争锁的情况下，它会自动升级为更重的锁类型，以确保线程间的正确同步。因此，当有其他线程参与竞争时，偏向锁会失效，并且对象会进入更严格的锁定状态，以防止数据不一致的问题。)
轻量级锁状态：
- 当第二个线程尝试获取同一个对象的锁时，偏向锁会被撤销，对象变为轻量级锁状态。
- 轻量级锁使用了ThreadLocal(这里的ThreadLocal是指JVM内部为每个线程维护的锁记录，而不是java.lang.ThreadLocal类。)变量来存储锁记录，而不是直接使用操作系统的互斥锁。
- 轻量级锁的机制允许两个线程通过自旋循环尝试获取锁，避免了立即进入重量级锁状态。
重量级锁状态：
- 当轻量级锁争用失败，例如线程被挂起、阻塞或中断，无法通过自旋获取锁时，JVM会将轻量级锁升级为重量级锁。
- 重量级锁涉及操作系统层面的互斥锁，可能会导致线程阻塞和上下文切换，从而增加了性能开销。
- 一旦升级为重量级锁，所有后续试图获取锁的线程都将被阻塞，直到锁被释放。

在这里插入图片描述

Synchronized使用场景

Synchronized是Java中用于实现线程同步的关键字，主要用于确保代码在多线程环境中的正确性和一致性。它支持两种基本的使用场景：同步方法和同步代码块。下面详细描述这两种使用场景及其适用场合：

同步方法

Synchronized可以修饰实例方法和静态方法，以控制对对象或类的访问。

实例方法

当你在方法声明前使用synchronized关键字，这个方法就变成了一个同步方法。每次只有一个线程可以执行该方法。锁是当前对象的实例。这意味着如果两个线程尝试同时调用同一个对象上的一个synchronized方法，只有一个线程可以进入该方法，而另一个线程将被阻塞，直到第一个线程完成方法的执行。

适用场景：

当多个线程可能同时访问同一个对象的共享数据，并且这些线程需要互斥地访问这些数据时，可以使用synchronized实例方法。
当方法中包含了对共享资源的操作，而这些操作必须保证原子性时，比如更新一个共享变量的值。

静态方法

当synchronized修饰静态方法时，锁是整个类的Class对象。这意味着所有实例共享同一个锁，当一个线程调用静态synchronized方法时，其他线程将无法调用同一个类的任何静态synchronized方法，直到第一个线程释放锁。

适用场景：

当需要确保在整个类的所有实例中对某个静态资源的互斥访问时，可以使用synchronized静态方法。
当静态方法中包含了对静态共享资源的操作，需要确保线程安全时。

同步代码块

除了同步方法外，synchronized还可以用于同步代码块，这样可以更精细地控制锁的范围。

同步代码块

在代码中，你可以指定一个锁对象，然后使用synchronized关键字将一段代码包裹起来。这样，锁的范围仅限于这个代码块，当线程退出代码块时，锁将自动释放。

适用场景：

当你需要在方法中对某些特定的代码片段进行同步，而不是整个方法时。
当需要在不同的方法中使用同一个锁对象，以确保这些方法之间的互斥访问。
当你希望避免整个方法的同步带来的性能影响，只在需要的地方同步代码。

synchronized关键字用于确保代码在多线程环境中的正确执行，它可以用于同步方法和同步代码块。选择哪种方式取决于具体的应用场景和对性能的需求。在实际应用中，应当注意synchronized的使用可能会影响程序的性能，因为它会导致线程阻塞，所以在不需要的地方避免过度使用同步机制。同时，现代JVM实现了一些优化，如锁的升级机制，来减少synchronized带来的性能开销。

对象头介绍

Java对象在内存中的布局通常分为三个部分：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。对象头是用于支持虚拟机实现类的元数据信息的地方，这些信息可能包括但不限于：

Mark Word（标记字段）:
标记字段是对象头中最重要的部分，它通常包含以下信息：
- 分代年龄: 表示对象属于哪一代（年轻代还是老年代），以及它在垃圾回收过程中的年龄（经过多少次Minor GC后仍然存活）。
- 锁状态标志: 表明对象的锁状态，如无锁、偏向锁、轻量级锁或重量级锁。
- 线程ID: 在偏向锁状态下，会记录拥有偏向锁的线程ID。
- 偏向时间戳: 偏向锁的创建时间，用于决定是否撤销偏向锁。
- 轻量级锁的锁记录指针: 在轻量级锁状态下，指向栈中锁记录的指针。
- 重量级锁的Monitor指针: 在重量级锁状态下，指向Monitor对象的指针。
- 哈希码: 对象的哈希码，用于hashCode()方法。
- GC标志: 标记对象是否可被垃圾回收等。
Class Metadata Address（类元数据地址）:
这是一个指向对象的类元数据的指针，即Class对象的指针。JVM通过这个指针来确定对象是哪个类的实例，以及如何访问类的方法区中的静态变量和方法信息。
Array Length（数组长度） (如果适用):
如果对象是一个数组，对象头还会包含一个额外的字段来存储数组的长度信息。

需要注意的是，对象头的具体布局和大小依赖于JVM的实现和使用的垃圾回收器。例如，HotSpot VM中对象头的布局可能会因不同的版本和配置而有所不同。此外，为了提高性能，JVM可能会使用指针压缩技术来节省内存，这也会影响对象头的结构。

在HotSpot VM中，Mark Word的布局可以动态改变，具体取决于对象的当前状态（比如锁的状态），并且为了性能考虑，Mark Word可能还包含了其他一些优化信息。

由于对象头的存在，Java中的对象比原始类型占用更多的内存。这是Java运行时环境为了实现其特性（如垃圾收集、线程安全和类的信息管理）所付出的代价。

锁膨胀过程

synchronized锁膨胀是指在Java虚拟机（JVM）中synchronized锁从一种低开销的状态升级到另一种更昂贵的状态的过程。锁膨胀是为了在不同的并发压力下优化锁的性能。下面是对锁膨胀过程的详细全面介绍：

无锁状态

在对象创建之初，它处于无锁状态，此时对象头中没有任何锁标志位。这意味着没有线程拥有该对象的锁，所有线程都可以自由地访问对象的非同步方法和字段。

偏向锁状态

当第一个线程尝试获取synchronized锁时，JVM会将对象头标记为偏向锁状态，并在对象头中记录获取锁的线程ID。只要没有其他线程试图获取这个锁，那么这个线程就可以快速地访问和退出同步区域，而不需要进行额外的同步检查。偏向锁假设锁的持有者不会改变，如果其他线程试图获取锁，则偏向锁会被撤销，升级为轻量级锁。

轻量级锁状态

当第二个线程试图获取同一个对象的锁时，JVM会撤销偏向锁并将对象头标记为轻量级锁状态。轻量级锁使用了每个线程的本地变量（ThreadLocal）来存储锁记录，这个记录包含了一个栈帧中的锁记录指针。当线程再次尝试获取锁时，它会尝试使用CAS（Compare and Swap）操作来更新对象头中的锁记录指针，从而获取锁。如果CAS成功，线程就可以获取锁；如果失败，则轻量级锁可能会升级为重量级锁。

重量级锁状态

当轻量级锁争用失败，例如在多个线程间竞争锁，或者当持有轻量级锁的线程被挂起、阻塞或中断时，JVM会将轻量级锁升级为重量级锁。重量级锁涉及操作系统级别的互斥锁（mutex），这通常会导致线程的阻塞和上下文切换，从而增加了系统的开销。重量级锁的获取和释放需要更多的系统资源，因此它是锁膨胀过程中的最后阶段。

锁膨胀的触发条件

锁的膨胀通常由以下因素触发：

锁争用：当多个线程竞争同一个锁时。
线程挂起/唤醒：当持有锁的线程被挂起或唤醒时，可能会导致锁升级。
线程中断：线程被中断也可能触发锁升级。
锁重入：当一个线程多次尝试获取同一个锁时。

锁优化

为了进一步优化锁的性能，JVM还实现了以下策略：

锁消减：当锁不再被需要时，例如当没有线程竞争时，JVM可能会将锁从重量级或轻量级降级回偏向锁甚至无锁状态。
锁剥离：在某些情况下，JVM会尝试将锁的粒度减小，比如使用细粒度锁或无锁数据结构来减少锁的竞争。

我们将通过示例代码来逐步解析这些状态。

无锁状态



在程序开始执行之前，对象处于无锁状态。此时，没有线程持有锁，对象头中也没有锁标志位。

```java
public class NoLockState {
    public static void main(String[] args) {
        Object obj = new Object();
        // 无锁状态，对象头中没有锁标志位
    }
}

偏向锁状态

当第一个线程尝试获取synchronized锁时，对象头将被标记为偏向锁状态。这意味着只有当前线程可以访问该对象，而不需要额外的同步开销。

public class BiasedLockExample {

    public static void main(String[] args) {
        Object obj = new Object(); // 创建新对象，初始为无锁状态
        
        synchronized (obj) { // 第一个线程获取锁，将进入偏向锁状态
            // 在这里，对象头中的锁标志位被设置为偏向锁模式，并记录了当前线程ID
            System.out.println("Thread " + Thread.currentThread().getId() + " has acquired the biased lock.");
        }
        
        // 当前线程释放锁后，对象保持偏向锁状态，直到有其他线程尝试获取锁
    }
}

轻量级锁状态

当另一个线程尝试获取同一对象的锁时，偏向锁会被撤销，对象头将被标记为轻量级锁状态。轻量级锁使用了ThreadLocal变量存储锁记录，减少了对互斥锁的依赖。

这里的ThreadLocal是指JVM内部为每个线程维护的锁记录，而不是java.lang.ThreadLocal类。在轻量级锁机制中，JVM会在每个线程的本地栈中保存一个锁记录（Lock Record），这个记录包含锁对象的一些信息，例如锁对象的Mark Word的拷贝。

public class LightweightLockExample {
    
    // 定义一个锁对象
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        // 创建第一个线程
        Thread t1 = new Thread(() -> {
            synchronized (lock) {  // 第一个线程尝试获取锁
                System.out.println("线程 " + Thread.currentThread().getId() + " 已经获取了偏向锁");
                try {
                    Thread.sleep(5000);  // 模拟长时间运行，以便让其他线程有机会尝试获取锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });


        // 创建第二个线程
        Thread t2 = new Thread(() -> {
            synchronized (lock) {  // 第二个线程尝试获取锁
                System.out.println("线程 " + Thread.currentThread().getId() + " 正在尝试获取锁");
            }
        });

        // 启动第一个线程
        t1.start();
        Thread.sleep(10);  // 确保t1线程先运行
        // 启动第二个线程
        t2.start();

        // 等待两个线程完成
        t1.join();
        t2.join();

        System.out.println("所有线程已执行完毕");
    }
}

在这个示例中：

Thread t1首先尝试获取lock对象上的锁，这时锁会进入偏向锁状态。
Thread t2随后尝试获取同一把锁，这时锁会从偏向锁状态升级为轻量级锁状态。
Thread t1中的Thread.sleep(5000)语句模拟了长时间运行的情况，这使得Thread t2在Thread t1释放锁之前就有机会尝试获取锁。
当Thread t2尝试获取锁时，由于Thread t1已经持有锁，因此Thread t2将进行自旋，等待锁的释放。

请注意，这个代码示例主要用来展示锁升级的过程，实际的锁升级机制是由JVM内部实现的，我们无法直接观察到锁状态的变化。此外，锁升级的具体行为也受到JVM参数和版本的影响。在不同的JVM实现和配置下，锁升级的行为可能会有所不同。

重量级锁状态

当轻量级锁争用失败（例如，线程被挂起、阻塞或中断）时，JVM会将轻量级锁升级为重量级锁。这涉及到操作系统层面的互斥锁，可能导致线程阻塞，从而增加上下文切换的开销。

public class HeavyweightLockExample {
     private static final Object lock = new Object();
    private static final CountDownLatch startSignal = new CountDownLatch(1); // 控制线程同时开始
    private static final CountDownLatch keepLock = new CountDownLatch(1);   //控制持有锁的线程何时释放锁

    public static void main(String[] args) throws InterruptedException {

        // 创建持有锁的线程
        Thread lockHolder = new Thread(() -> {
            try {
                startSignal.await(); // 等待所有线程准备就绪
                synchronized (lock) {
                    System.out.println("线程 " + Thread.currentThread().getId() + " 正在持有锁");
                    keepLock.await(); // 阻塞直到收到信号释放锁
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 创建多个尝试获取锁的线程
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> {
                try {
                    startSignal.await(); // 等待所有线程准备就绪
                    synchronized (lock) {
                        System.out.println("线程 " + Thread.currentThread().getId() + " 正在尝试获取锁");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 启动持有锁的线程
        lockHolder.start();

        // 启动所有尝试获取锁的线程
        for (Thread thread : threads) {
            thread.start();
        }

        // 释放计数器，允许所有线程开始尝试获取锁
        startSignal.countDown();

        // 立即检查线程状态，以捕捉到线程在等待锁时的BLOCKED状态
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(true, true);
        for (ThreadInfo info : threadInfos) {
            // 打印每个线程的状态和锁信息，以帮助理解锁的使用情况
            System.out.println("线程 " + info.getThreadId() + " 的状态: " + info.getThreadState());
            if (info.getThreadState() == Thread.State.BLOCKED) {
                System.out.println("线程 " + info.getThreadId() + " 被阻塞在锁上");
            }
        }

        // 在此之后，释放锁持有线程的阻塞，允许它释放锁
        keepLock.countDown();

        // 等待所有线程完成
        for (Thread thread : threads) {
            thread.join();
        }
        lockHolder.join();

        System.out.println("所有线程已执行完毕");
    }
}

这段代码主要用来演示在多线程环境中，当多个线程试图获取同一个锁时，如何观察到线程状态的变化，尤其是BLOCKED状态，这与重量级锁的概念紧密相关。重量级锁是当多个线程竞争同一个锁时，JVM采用的一种锁升级策略，它会导致未获取到锁的线程阻塞，从而增加上下文切换的开销。

下面是代码的详细解释：

定义锁和同步机制:
- lock: 定义了一个对象实例，它将被用作synchronized关键字的锁。
- startSignal: CountDownLatch实例，用于控制所有线程的启动。当计数器到达零时，所有等待的线程将被释放。
- keepLock: 另一个CountDownLatch实例，用于控制持有锁的线程何时释放锁。
创建线程:
- lockHolder: 一个线程，它的任务是在其他线程开始尝试获取锁之前获取锁，并在接收到keepLock的信号前一直持有锁。
- threads: 一个包含10个线程的数组，这些线程将在startSignal的信号后尝试获取锁。
启动线程:
- 首先启动lockHolder线程，然后启动所有其他的线程。
同步线程:
- startSignal.countDown(): 释放所有线程，允许它们开始尝试获取锁。
检查线程状态:
- 使用ThreadMXBean和dumpAllThreads方法获取所有线程的信息，包括它们的状态。
- 当一个线程的状态是BLOCKED时，这通常意味着它正在等待锁。这是因为当一个线程尝试获取已经被其他线程持有的锁时，它会被阻塞，直到锁被释放。
释放锁:
- keepLock.countDown(): 发送信号给lockHolder线程，允许它释放锁。
等待所有线程完成:
- 使用join方法等待所有线程执行完毕。
结束信息:
- 打印一条消息，表示所有线程已经完成执行。