首页 死磕 Java 优质系列 Java 技术总览 Java 面试宝典 关于我
logo

Java 面试宝典：synchronized 的实现原理是怎样的？

原
 2024-03-23  阅读(106)
©版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://www.skjava.com/mianshi/baodian/detail/1775246437

回答

synchronized 是 Java 中一个重量级的关键字，它用于实现线程同步，确保多线程环境下对共享资源的安全访问。它可以修饰方法或代码块，保证一次只有一个线程可以执行同步方法或代码块内的代码。

synchronized有两种形式上锁，一个是对方法上锁，一个是对代码块上锁。其实他们底层实现原理都是一样的。在进入同步代码之前先获取锁，锁计数 + 1，执行完同步代码后释放锁，锁计数 -1，如果获取失败就阻塞式等待锁的释放。他们的不同之处在于他们在同步块的识别方式有所不同。

当一个方法被 synchronized 修饰时，它的方法标志中会包含 ACC_SYNCHRONIZED 标志。当某个线程要访问方法时，会首先检查是否有 ACC_SYNCHRONIZED 设置，如果有，则需要先获取监视器锁，获取成功后才能执行方法，方法执行完成后再释放监视器锁。如果在该线程执行同步方法期间，有其他线程来请求执行方法，会因为无法获取监视器锁而阻塞。

而同步代码块则是使用 monitorenter 和 monitorexit 指令来实现的。我们可以理解执行 monitorenter 为加锁，执行 monitorexit 为释放锁。每个对象都维护着一个锁的计数器，为被锁定的对象该计数器为 0。当一个线程在执行 monitorenter 之前需要尝试后去锁，如果这个对象没有被锁定，或者当前线程已经拥有了该对象的锁，那么这把锁的计数器 + 1，当执行monitorexit指令时，锁的计数器也会减1。

扩展

基本使用

Synchronized 是 Java 中解决并发问题的一种最常用的方法，也是最简单的一种方法。Synchronized的作用主要有三个：

  1. 原子性：确保线程互斥的访问同步代码
  2. 可见性：保证共享变量的修改能够及时可见。
  3. 有序性：有效解决重排序问题。

从语法上讲，Synchronized 可以把任何一个非null对象作为 “锁”，在HotSpot JVM实现中，这个锁有个专门的名字：对象监视器（Object Monitor）。

从语法上讲，synchronized总共有三种用法，三种用法锁定的对象都不同：

  • 当 synchronized 用于实例方法时，监视器锁（monitor）便是对象实例（this）。
public synchronized void method() {
    // 方法体
}

锁定的是调用该方法的对象实例。

  • 当Synchronized 用于静态方法时，监视器锁（monitor）便是对象的Class实例。
public static synchronized void staticMethod() {
    // 方法体
}

锁定的是这个类的所有对象。

  • 当Synchronized 用于同步代码块时，监视器锁（monitor）便是括号括起来的对象实例。
public void method() {
    synchronized (object) {
        // 代码块
    }
}

同步实现原理

同步需要依赖锁，那锁的同步又依赖谁？synchronized 给出的答案是在软件层面依赖JVM。我们来看同步方法和同步代码块是如何实现的。

同步方法

代码如下：

public class SynchronizedTest {
    public synchronized void test() {
        System.out.println("死磕 Java 面试...");
    }
    
    // 为了对比
    public  void test1() {
        System.out.println("死磕 Java 面试...");
    }
}

使用 javac SynchronizedTest.java，编译 Java 文件为 .class 文件，然后使用 javap -verbose SynchronizedTest，结果如下：

对于普通方法，其实就是常量池中多了 ACC_SYNCHRONIZED 标识符，JVM就是根据该标示符来实现方法的同步的：

当方法被调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先获取 monitor ，获取成功之后才能执行方法体，方法执行完后再释放 monitor。在方法执行期间，其他任何线程都无法再获得同一个monitor对象。

同步代码块

代码如下：

public class SynchronizedTest {
    public void test() {
        synchronized (this) {
            System.out.println("死磕 Java 面试...");
        }
    }
}

反编译 .class 文件，内容如下：

如上面所提到的执行 monitorenter 为加锁，执行 monitorexit 为释放锁。

每个对象都是一个监视器锁。当monitor被占用时就会处于锁定状态。

执行 monitorenter 过程如下：

  1. 如果 monitor 的计数为 0，说明锁未被持有，JVM 将锁分配给执行 monitorenter 的线程，并将 monitor 的计数设置为 1。
  2. 如果线程已经占有了该 monitor，当前线程重入，monitor 的计数 + 1。
  3. 如果 monitor 被其他线程持有，那么当前线程将被阻塞，直到锁被释放。

执行 monitorexit 的过程：

  • 执行 monitorexit 的线程必须是对应 monitor 的所有者，即执行 monitorexit 和 monitorenter 要是同一个线程。
  • 执行 monitorexit 时，monitor 的计数器 - 1，如果计数器大于 0，表示当前线程还持有 monitor（可重入），锁不会被释放，如果计数器等于 0，表示当前线程不再持有 monitor ，锁被释放。
  • monitorexit 指令出现两次，原因是为了兼顾执行同步代码时出现异常而导致锁无法释放的问题。所以第1次为同步正常退出释放锁，第2次为发生异步退出释放锁。

监视器（monitor）

synchronized在 JVM 中的实现都是基于进入和退出monitor对象来实现方法同步和代码块同步，所以我们有必要来了解下 monitor。

那什么是 monitor 呢？我们可以把它理解为一种同步机制，它通常被描述为一个对象。

我们知道，在 Java 中一切皆对象，同理，在 Java 中所有的 Java 对象是天生的 monitor，每一个 Java 对象都有成为 monitor 的可能。这是因为在Java的设计中 ，每一个Java对象自打娘胎里出来就带了一把看不见的锁**，它叫内置锁**。

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 ;
  }

几个重要属性如下：

  • _header：指向对象头，在 Java 中，每个对象都有一个对象头，其中包含了与锁和垃圾收集相关的信息。
  • _count：用于记录重入锁的数量。在 Java 中，同一个线程可以多次获得同一个锁（即重入锁），这个字段就是用来记录该线程获取锁的次数。
  • _recursions：用于记录同一个线程重复获取这个锁的次数。
  • _waiters：记录正在等待获取这个对象锁的线程数量。
  • _owner：当前拥有这个 monitor 的线程
  • _WaitSet：处于 wait 状态的线程，会被加入到 _WaitSet 中，可通过 notify() 或 notifyAll() 唤醒。
  • _EntryList：处于等待锁 block 状态的线程，会被加入到 _EntryList 中。

ObjectMonitor 中有两个队列，_WaitSet 和 _EntryList，用来保存 ObjectWaiter 对象列表（ 每个等待锁的线程都会被封装成 ObjectWaiter对象 ），_owner指向持有ObjectMonitor对象的线程，当多个线程访问一段同步代码时：

  1. 首先会进入 _EntryList 集合，当线程获取到对象的 monitor 后，进入 _owner 区域并把 monitor 中的_owner变量设置为当前线程，同时monitor中的计数器_count加1；
  2. 若持有 monitor 的线程调用 wait()，将释放当前持有的monitor，_owner变量恢复为null，_count自减1，同时该线程进入 _WaitSet集合中等待被唤醒；
  3. 若持有 monitor 的线程执行完毕，也将释放当前持有的 monitor，并复位变量的值，以便其他线程进入获取monitor；

阅读全文
  • 点赞