聊一聊java中synchronized的实现原理

关注

原创最新推荐文章于 2026-05-02 09:25:56 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

51单片机基础知识前言周末闲着无聊，以后定时更新一期关于51单片机的学习案例，以供大家平时参考使用。至于单片机，你可以理解为人的大脑，而人各项身体器官的运作需要意识给到大脑，然后大脑再驱动我们的中枢神经进行相应的动作，这里的意识可以理解为我们要写的程序，而人的器官相当于各种输出设备，例如我们以后要学的LED、电机、各种传感器等等。学好单片机能让你找到一份相对不错的工作，当然越可观的东西也是要付出相应努力的。一、51单片机是什么？通常我们一说到 51 单片机，指的都是兼容IntelMCS-51体系架构的一系列单片机，而阅读详情

是什么：

synchronized 是 Java 中用于控制多个线程对共享资源的访问的关键字，以确保在并发环境中数据的完整性和一致性。

synchronized 关键字可以作用于方法或代码块中。

代码示例：

public class SynchronizedTest {

    private int count = 0;

    /**
     * synchronized用在方法上
     */
    public synchronized void increase() {
        count++;
    }

    /**
     * synchronized用在代码块上
     */
    public void increase2() {
        synchronized (this) {
            count++;
        }
    }
}

实现原理：

synchronized 的实现原理主要基于 Java 的内存模型以及对象锁机制。

Java 内存模型

Java 内存模型（JMM）定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存中，每个线程都有一个私有的本地内存，本地内存中存储了该线程使用到的主内存副本的拷贝，线程对变量的所有操作（读取、赋值等）都必须在自己的本地内存中进行，而不能直接读写主内存中的变量。

锁机制

synchronized 关键字在 Java 中的常用使用方式：

修饰实例方法：作用于当前实例加锁，进入同步代码前要获得当前实例的锁。
修饰静态方法：作用于当前类对象加锁，进入同步代码前要获得当前类对象的锁。
修改代码块：指定加锁对象，进入同步代码块前要获得指定对象的锁。

当线程进入 synchronized 修饰的方法或代码块时，它会尝试获取对象的锁。如果锁已被其他线程持有，则当前线程会阻塞，直到持有锁的线程释放锁。一旦线程获取到锁，它就可以安全地执行同步代码块中的操作，而不会被其他线程打断。

实现细节：

当深入探讨 synchronized 的实现细节时，我们需要考虑 JVM、字节码指令、锁的状态以及锁升级等多个方面。

1. JVM 层面的支持

JVM 通过内部对象监视器（也称为 Monitor 或内置锁，下一节介绍）来实现 synchronized。每个对象都有一个与之关联的监视器锁，当线程进入 synchronized 代码块或方法时，JVM 会尝试获取该对象的监视器锁。

2. 字节码指令

当编译器遇到 synchronized 关键字时，它会生成特定的字节码指令来处理同步逻辑。例如，对于实例方法的同步，编译器会插入 monitorenter 和 monitorexit 指令。当线程执行到 monitorenter 指令时，它会尝试获取对象的锁；当执行到 monitorexit 指令时，它会释放对象的锁。

3. 锁的状态与偏向锁

为了优化性能，JVM 中的锁有多种状态，包括无锁状态、偏向锁状态、轻量级锁状态和重量级锁状态。synchronized 的实现会根据锁的状态和竞争情况来进行相应的优化。

偏向锁：这是 JVM 的一种锁优化手段。当一个线程首次访问同步代码块并获取锁时，JVM 会将锁对象头中的标记位设为“偏向模式”，记录持有锁的线程 ID，以后该线程进入和退出同步块时不需要进行 CAS 操作来加锁和解锁，只需检查是否为偏向锁以及锁是否指向当前线程的 ID。偏向锁可以提高无竞争情况下的性能。

4. 锁升级

当锁竞争加剧时，JVM 会进行锁升级来确保线程安全。

轻量级锁：当多个线程交替访问同步块时，JVM 会尝试使用轻量级锁来避免线程阻塞。轻量级锁通过 CAS（Compare-and-Swap）操作来尝试获取锁，如果成功则继续执行，如果失败则进入自旋等待状态，尝试重新获取锁。轻量级锁可以减少线程阻塞的开销，但在竞争激烈的情况下可能会导致 CPU 自旋消耗过多资源。
重量级锁：当轻量级锁无法满足需求时，JVM 会将锁升级为重量级锁。重量级锁采用传统的互斥量（Mutex）机制来实现，线程在获取锁时会进入阻塞状态，等待其他线程释放锁。重量级锁可以确保线程安全，但可能导致线程频繁阻塞和唤醒，降低性能。

5. 锁的释放与可重入性

当一个线程持有某个对象的锁时，它可以多次进入由同一把锁保护的同步块，这就是锁的可重入性。JVM 通过维护一个计数器来记录线程对锁的重入次数，每次线程进入同步块时计数器加一，退出时减一，当计数器为零时释放锁。

6. 公平性与非公平性

synchronized 默认的锁是非公平的，即等待获取锁的线程不一定按照它们请求锁的顺序来获取锁，这可能导致饥饿现象（某些线程长时间得不到执行）。虽然 JVM 也支持公平锁，但 synchronized 关键字本身并不直接提供公平锁的实现。如果需要公平锁，可以使用 java.util.concurrent.locks 包中的 ReentrantLock 类，并设置其公平性参数为 true。

JVM 内部对象监视器Monitor

JVM中的内部对象监视器（也称为Monitor或内置锁）是Java并发编程中的一个核心概念，它提供了一种机制来确保同一时间只有一个线程可以执行某个代码段，从而实现对共享资源的同步访问。

监视器可以理解为一个特殊的房间，这个房间同一时刻只能有一个线程进入。这个房间中包含了一些数据和代码，这些数据和代码在任意时刻只能被一个线程访问。当一个线程想要进入这个特殊房间时，它首先需要在“走廊”（Entry Set）中排队等待。调度器将基于某种标准（如FIFO）来选择排队的线程进入房间。如果因为某些原因，线程暂时无法继续执行（例如，线程被挂起），它将被送到另一个专门用于等待的房间（Wait Set），并可以在稍后再次尝试进入特殊房间。

操作系统的管程（monitor）是概念原理，ObjectMonitor是它的原理实现。

在Java虚拟机（HotSpot）中，Monitor（管程）是由ObjectMonitor实现的，其主要数据结构如下：

ObjectMonitor() {
    _header       = NULL;
    _count        = 0; // 记录个数
    _waiters      = 0,
    _recursions   = 0;
    _object       = NULL;
    _owner        = NULL;
    _WaitSet      = NULL;  // 处于wait状态的线程，会被加入到_WaitSet
    _WaitSetLock  = 0 ;
    _Responsible  = NULL ;
    _succ         = NULL ;
    _cxq          = NULL ;
    FreeNext      = NULL ;
    _EntryList    = NULL ;  // 处于等待锁block状态的线程，会被加入到该列表
    _SpinFreq     = 0 ;
    _SpinClock    = 0 ;
    OwnerIsThread = 0 ;
  }

Java Monitor的工作机理：

想要获取monitor的线程，首先会进入_EntryList队列；
当某个线程获取到对象的monitor后，进入Owner区域，设置为当前线程，同时计数器count加1；
如果线程调用了wait()方法，则会进入WaitSet队列。它会释放monitor锁，即将owner赋值为null,count自减1,进入WaitSet队列阻塞等待。
如果其他线程调用 notify() / notifyAll() ，会唤醒WaitSet中的某个线程，该线程再次尝试获取monitor锁，成功即进入Owner区域。
同步方法执行完毕了，线程退出临界区，会将monitor的owner设为null，并释放监视锁。

在Java中，每个对象都有一个与之关联的监视器。当线程进入synchronized代码块或方法时，它会自动获取该对象的监视器锁，并在退出synchronized代码块或方法时释放该锁。如果其他线程试图获取已经被锁定的对象的监视器锁，它将被阻塞，直到当前线程释放锁为止。

Java对象头中的MarkWord部分存储了与锁相关的信息，如锁状态标志、线程持有的锁等。这使得JVM能够跟踪和管理对象的锁定状态。

总的来说，JVM中的内部对象监视器是一种强大的同步工具，它有助于程序员编写出线程安全的代码，从而避免数据竞争和不一致等问题。然而，过度使用或不当使用监视器也可能导致性能下降或死锁等问题，因此在使用时需要谨慎。