synchronized 的底层原理

激流丶

已于 2023-06-07 11:33:12 修改

阅读量4.1k

点赞数 7

分类专栏： JUC 并发编程文章标签： jvm java 面试

于 2023-06-05 22:49:45 首次发布

本文链接：https://blog.csdn.net/qq_37967783/article/details/131056740

版权

JUC 并发编程专栏收录该内容

13 篇文章 1 订阅

订阅专栏

tip: 作为程序员一定学习编程之道，一定要对代码的编写有追求，不能实现就完事了。我们应该让自己写的代码更加优雅，即使这会费时费力。

推荐：体系化学习Java（Java面试专题）

一、synchronized 的底层原理

synchronized 的底层是通过 Java 中的**监视器锁（monitor）**来实现的。每个 Java 对象都有一个与之对应的监视器锁，当一个线程获取了该对象的监视器锁，就可以执行 synchronized 代码块或方法。其他线程只能等待该线程释放锁，才能获取该对象的监视器锁并执行 synchronized 代码块或方法。

在 Java 中，每个对象都有一个与之关联的管程（monitor）。管程包括两个部分：一个是对象头（Object Header），用于存储对象的元数据信息；另一个是监视器锁（Monitor Lock），用于实现线程同步。当一个线程获取了对象的监视器锁，就可以执行 synchronized 代码块或方法，其他线程只能等待该线程释放锁，才能获取该对象的监视器锁并执行 synchronized 代码块或方法。

当一个线程进入 synchronized 代码块或方法时，它会尝试获取对象的监视器锁。如果该锁没有被其他线程占用，则该线程获取锁并继续执行 synchronized 代码块或方法；如果该锁已经被其他线程占用，则该线程会进入锁池（Lock Pool）等待，直到该锁被其他线程释放。

当一个线程释放对象的监视器锁时，它会唤醒锁池中的一个等待线程，让其获取锁并继续执行 synchronized 代码块或方法。如果锁池中有多个等待线程，那么唤醒哪个线程是不确定的，取决于 JVM 的实现。

二、synchronized 的锁升级原理

synchronized 的锁升级指的是在不同的情况下，synchronized 锁的状态会从偏向锁、轻量级锁、重量级锁等级别逐步升级的过程。在 Java 6 及之前的版本中，synchronized 的锁升级过程是固定的，而在 Java 6 及之后的版本中，锁升级过程是根据当前锁的状态和竞争情况动态调整的。

偏向锁：当一个线程访问同步块并获取锁时，会在对象头中记录锁偏向的线程 ID，以后该线程再次进入同步块时，只需判断当前线程 ID 是否与对象头中记录的线程 ID 相同，如果相同，就可以直接进入同步块，无需进行额外的同步操作。如果有其他线程竞争锁，则偏向锁会被撤销。

轻量级锁：当一个线程获取锁失败时，会尝试使用轻量级锁来提高性能。轻量级锁是通过将对象头中的信息复制到线程的栈帧中，然后在栈帧中进行同步操作来实现的。如果在同步过程中发生竞争，则轻量级锁会升级为重量级锁。

重量级锁：当多个线程竞争同一个锁时，会升级为重量级锁。重量级锁是通过操作系统的互斥量来实现的，每次加锁和释放锁都需要进行系统调用，开销较大。

在 Java 6 及之前的版本中，锁升级过程是固定的，即从偏向锁升级到轻量级锁，再升级到重量级锁。而在 Java 6 及之后的版本中，锁升级过程是根据当前锁的状态和竞争情况动态调整的，可以根据实际情况选择偏向锁、轻量级锁或重量级锁，从而提高程序的性能。

1、偏向锁

偏向锁是 Java 中的一种锁优化机制。它的主要目的是减少无竞争情况下的同步操作，从而提高程序的性能。在偏向锁的情况下，当一个线程访问同步块并获取锁时，会在对象头中记录锁偏向的线程 ID，以后该线程再次进入同步块时，只需判断当前线程 ID 是否与对象头中记录的线程 ID 相同，如果相同，就可以直接进入同步块，无需进行额外的同步操作。

偏向锁的优点是可以减少同步操作的开销，尤其是在无竞争的情况下。在无竞争的情况下，偏向锁可以避免多余的同步操作，从而提高程序的性能。另外，偏向锁的实现比较简单，开销也比较小。

偏向锁的缺点是当有其他线程竞争锁时，偏向锁会被撤销，这样就会导致额外的同步操作，从而降低程序的性能。此外，偏向锁只适用于无竞争的情况，如果存在竞争，就需要使用其他的锁机制来保证线程安全。

需要注意的是，偏向锁只适用于单线程访问同步块的情况。如果多个线程访问同一个同步块，就会出现竞争，此时偏向锁会被撤销，从而降低程序的性能。

package com.pany.camp.lock;

import org.openjdk.jol.info.ClassLayout;

public class BiasedLockDemo {

    public static void main(String[] args) throws InterruptedException {
        BiasedLockDemo biasedLockDemo = new BiasedLockDemo();
        biasedLockDemo.doSomething();
        System.out.println(ClassLayout.parseInstance(biasedLockDemo).toPrintable());
    }

    public synchronized void doSomething() {
        System.out.println("doSomething() is called");
    }
}

在这里插入图片描述
在上面的输出中，我们可以看到对象头中的第一个字节是 01 ，这个字节的二进制表示是 00000001 ，其中第0位是1，表示这个对象的锁是偏向锁。如果第0位是0，表示这个对象的锁不是偏向锁。

可以通过 -xx:UseBiasedLocking 禁用偏向锁。

2、轻量级锁

轻量级锁是Java虚拟机为了提高多线程程序性能而引入的一种锁优化机制。与传统的重量级锁相比，轻量级锁的锁操作使用了更加轻量级的机制，避免了不必要的线程阻塞和上下文切换，从而提高了多线程程序的执行效率。

轻量级锁的实现原理是，当一个线程第一次进入同步代码块时，Java虚拟机会为该对象分配一个锁记录（Lock Record）并将对象头中的Mark Word复制到锁记录中。然后，虚拟机会尝试使用CAS操作将对象头中的Mark Word替换为指向锁记录的指针，从而将对象的锁状态升级为轻量级锁。如果CAS操作成功，该线程就可以继续执行同步代码块，否则就会退化为重量级锁，从而保证线程安全。

当一个线程持有轻量级锁时，其他线程可以使用CAS操作来尝试获取锁。如果获取成功，就可以继续执行同步代码块。如果获取失败，就会进入自旋状态，等待持有锁的线程释放锁。如果自旋次数超过一定阈值，或者持有锁的线程被阻塞，就会退化为重量级锁。

总之，轻量级锁是Java虚拟机为了提高多线程程序性能而引入的一种锁优化机制，它避免了不必要的线程阻塞和上下文切换，从而提高了多线程程序的执行效率。

package com.pany.camp.lock;

import cn.hutool.core.thread.ThreadUtil;
import org.openjdk.jol.info.ClassLayout;

public class LightLock {
    private int count = 0;

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

    public static void main(String[] args) {
        final LightLock obj = new LightLock();
        final int numThreads = 5;
        final int numIterations = 10000;

        Thread t1 = new Thread(() -> {
            ThreadUtil.sleep(1000);
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }, "t1");
        t1.start();

        // 创建多个线程并启动
        Thread[] threads = new Thread[numThreads];
        for (int i = 0; i < numThreads; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < numIterations; j++) {
                    // 对共享对象加锁
                    synchronized (obj) {
                        obj.increment();
                        ThreadUtil.sleep(1);
                    }
                }
            });
            threads[i].start();
        }


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