Java锁机制

甜瓜瓜哥

已于 2025-08-11 16:03:10 修改

阅读量2.3k

点赞数

CC 4.0 BY-SA版权

分类专栏： Java 文章标签： java jvm 开发语言

于 2023-04-11 20:32:27 首次发布

本文链接：https://blog.csdn.net/qq_46130027/article/details/129975185

Java 专栏收录该内容

293 篇文章

订阅专栏

文章详细介绍了Java中的锁机制，包括公平锁与非公平锁、可重入锁、自旋锁和重量级锁的概念及实现原理。还讨论了synchronized的Monitor原理，以及锁的四种状态：无锁、偏向锁、轻量级锁和重量级锁的升级过程。此外，提到了JVM运行时内存结构对线程安全的影响，并举例说明了线程同步工具如CountDownLatch、CyclicBarrier和Semaphore的用途。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. 什么是锁

在并发环境下，多个线程会对同一个资源进行争抢。可能会导致数据不一致的问题。为了解决这个问题，很多编程语言都引入了锁机制。

通过一种抽象的锁来对资源进行锁定。

1.1 锁的分类

1.1.1 公平锁

队列模式，new ReentrantLock(true)

ReentrantLock 是 Java 中的一个类，属于 java.util.concurrent.locks 包。它实现了 Lock 接口，并提供了比 synchronized 关键字更灵活的锁机制。其主要特点如下：

可重入性：锁是可重入的，意味着同一个线程可以多次获取同一把锁，而不会导致死锁。例如，如果线程 A 获取了锁，它可以再次获取该锁，锁的计数器会增加，直到线程 A 调用 unlock() 解锁相同次数的锁。
公平性：ReentrantLock 可以创建公平锁或者非公平锁。公平锁保证按照线程请求锁的顺序进行授予；非公平锁则不保证这种顺序（默认是非公平锁），可能会造成“线程饥饿”现象。
显式锁管理：与 synchronized 块相比，ReentrantLock 需要显式调用 lock() 来加锁，调用 unlock() 来解锁。这样可以在某些情况下提供更细粒度的锁控制，例如在 try 块中使用 finally 块来保证释放锁。
条件变量支持：ReentrantLock 提供了 newCondition() 方法，可以创建与锁关联的条件变量，用于实现线程之间的通信，例如 await() 和 signal()。
可响应中断：lockInterruptibly
支持超时尝试：tryLock(timeout, unit)

    ReentrantLock lock = new ReentrantLock();
    lock.lock();
    try {
        // 临界区代码
    } finally {
        lock.unlock();
    }

1.1.2 非公平锁

可以插队（可造成优先级反转和饥饿的现象）

使用new ReentrantLock（）无参构造，默认是非公平锁。

1.1.3 可重入锁（递归锁）

ReentrantLock/Synchronized类似于大门钥匙——防止死锁。

同一线程外层函数获取锁后，内层递归函数仍然能获取该锁（内层会自动获取锁）。

即：线程可以进入任何一个它已经拥有的锁所同步着的代码块。

1.1.4 自旋锁

尝试获取锁的线程不会立即阻塞，而是采用循环的方式尝试获取锁。

好处：减少线程上下文切换的消耗。
缺点：循环会消耗CPU。

1.1.5 独占锁（写锁）

该锁一次只能被一个线程所持有。ReetrantLock/Synchronized

1.1.6 共享锁（读锁）

该锁可被多个线程所持有。

1.2 ReentrantReadWriteLock

读锁是共享锁，写锁是独占锁，适合读多写少场景。

读锁的共享锁可保证并发读是非常高效的，读写、写读、写写的过程是互斥的。

写操作：原子+独占

写锁降级为读锁（持有写锁时可获取读锁，反之不行）。

   ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
   rwLock.readLock().lock();  // 获取读锁
   rwLock.writeLock().lock(); // 获取写锁

1.3 StampedLock（邮戳锁，JDK8+）

特点：
支持乐观读（不阻塞写操作）。
提供tryConvertToWriteLock()等高级功能。

   StampedLock stampedLock = new StampedLock();
   long stamp = stampedLock.tryOptimisticRead(); // 乐观读
   if (!stampedLock.validate(stamp)) {
       stamp = stampedLock.readLock(); // 升级为悲观读
   }

1.4 Condition（条件变量）

作用：与ReentrantLock配合，实现线程间条件等待（类似wait()/notify()）。

   Condition condition = lock.newCondition();
   condition.await();  // 等待
   condition.signal(); // 唤醒

1.5 线程排序常用锁

1.5.1 CountDownLatch

线程减到0才执行主线程（不断做减法）。

latch的中文翻译是门闩。

1.5.2 CyclicBarrier

集齐7颗龙珠，可以召唤神龙（不断做加法）。

1.5.3 Semaphore

信号灯，多个线程抢多份资源（示例：争车位）。
作用：一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

1.6 锁总结

在这里插入图片描述
常见锁：synchronized、ReentrantLock、读写锁、StampedLock。
锁升级：无锁→偏向锁→轻量级锁→重量级锁，根据竞争动态调整。
选择依据：根据线程竞争强度、功能需求（如超时）和性能要求综合判断。

2. JVM运行时内存结构

JVM运行时内存结构主要包含了程序计数器、JVM栈、Native方法栈、堆、方法区。
在这里插入图片描述

下面一层中蓝色区域是所有线程共享的数据区域。

上面一层红色区域是各个线程私有的，对于这个区域中的数据，不会出现线程竞争的问题（线程安全）。

Java堆中存放的是所有对象。

方法区中存放的是类信息，常量，静态变量相关信息。

当多个线程竞争其中的一些数据时会发生难以预料的异常情况。因此需要锁机制对其进行限制。

3. 对象、对象头结构

在Java中，每个object，也就是每个对象都拥有一把锁，锁中记录了当前对象被哪个线程所占用。

对象的结构：对象头 + 实例数据 + 对齐填充字节

在这里插入图片描述

Class Point就是一个指针，指向了当前所在对象类型所在方法区中的类型数据。

在这里插入图片描述

3.1 Mark Word中的字段

Mark Word存储了很多和当前对象运行时状态信息有关的数据。比如说hashcode、锁状态标志、指向锁记录的指针、偏向锁ID等等。其中最重要的是锁标志位。

在这里插入图片描述

4. synchronized

Java中的synchronized关键词可以用来同步线程。该关键字是基于JVM实现的隐式锁，用于方法或代码块。

synchronized被编译后会生成monitorenter和monitorexit两个字节码指令。依赖这两个字节码指令来进行线程同步。

特点：

自动获取和释放锁（进入同步块获取，退出时释放）。
支持锁升级（偏向锁→轻量级锁→重量级锁）。

4.1 Monitor原理

monitor依赖于操作系统的mutex lock来实现的。

Java线程实际上是对操作系统线程的映射。所以每当挂起或者唤醒一个线程都要切换操作系统内核态。这种操作是比较重量级的。在一些情况下甚至切换时间本身将会超出线程执行任务的时间。这样的话，使用synchronized将会对程序的性能产生很严重的影响。

4.2 四种锁状态的发展

但是从Java6开始，synchronized进行了优化，引入了偏向锁、轻量级锁，所以锁总共有四种状态。从低到高分别是无锁、偏向锁、轻量级锁、重量级锁。这就分别对应了Mark Word中的四种状态。

需要注意的是锁只能升级不能降级。

在这里插入图片描述

5. 锁的4种状态

5.1 无锁

没有对资源进行锁定。所有线程都可以访问到同一资源，对象未被任何线程锁定。

这会出现两种情况：

某个对象不会出现在多线程环境下，或者说即使出现在了多线程环境下也不会出现竞争的情况。那么确实无需对这个对象进行任何保护，直接让他给任何线程随意调用即可。
资源会被竞争，但是不希望资源被锁定。不过还是想通过一些机制来控制多线程。

5.1.1 CAS（Compare and Swap）

如果有多个线程想要修改一个值，我们不通过锁定资源的方式而是通过其他方式来限制同时只有一个线程能够修改成功，而其他修改失败的线程将会不断重试直到修改成功。

CAS在操作系统中通过一条指令来实现，所以它就可以保证原子性。通过诸如CAS这种方式，我们可以进行无锁编程。

5.2 偏向锁

触发条件：首次有线程访问同步块。

原理：

在对象头记录线程ID（无需CAS操作）
适用于只有一个线程访问的场景

优势：消除同步开销（仅一次CAS设置线程ID）

假如一个对象被加锁了，但在实际运行时只有一个线程会获取这个对象锁。那么我们最理想的方式就是不通过线程切换，也不要通过CAS来获得锁。

因为这样多多少少还是会耗费一些资源。我们设想的是最好对象能够认识这个线程。只要这个线程过来，那么对象就直接把锁交出去。我们就可以认为这个对象偏爱这个线程，所以被称为偏向锁。

5.2.1 实现原理

在这里插入图片描述
在Mark Word中，当锁标志位是01时，那么判断倒数第三个bit是否为1。如果是1，那么代表当前对象的锁状态为偏向锁。否则则为无锁。

如果当前对象的锁状态为偏向锁，于是再去读Mark Word的前23个bit，这23个bit的值就是线程ID。通过线程ID来确认当前想要获得对象锁的这个线程是不是老顾客。

假如情况发生了变化，对象发现目前不只有一个线程而是有多个线程正在竞争锁，那么偏向锁将会升级为轻量级锁。当锁的状态还是偏向锁时，是通过Mark Word中的线程ID来找到占有这个锁的线程。

那么当锁的状态升级到轻量级锁时，如何判断线程和锁之间的关系呢

5.3 轻量级锁

触发条件：发生锁竞争（第二个线程尝试获取锁）。

原理：

通过CAS操作将对象头替换为指向线程栈中锁记录的指针。
若CAS失败，说明存在竞争，升级为重量级锁。

优势：避免线程阻塞（自旋等待）。

当一个线程想要获得某个对象的锁时，假如看到锁标志位为00那么就知道它是轻量级锁。

5.3.1 如何判断线程和锁之间的绑定关系

将前30个bit变为指向线程栈中锁记录的指针。当一个线程想要获得某个对象的锁时，假如看到锁标志位为00，那么就知道它是轻量级锁。

这时线程会在自己的虚拟机栈中开辟一块被称为Lock Record的空间（线程私有的）。Lock Record中存放的是对象头中的Mark Word的副本以及owner指针。线程通过CAS去尝试获取锁。一旦获得那么将会复制该对象头中的Mark Word到Lock Record中。并且将Lock Record中的owner指针指向该对象。另一方面，对象的Mark Word的前30个bit将会生成一个指针指向线程虚拟机栈中的Lock Record。

这样一来，就实现了线程和对象锁的绑定。他们就互相知道了对方的存在。

在这里插入图片描述

这样这个对象就已经被锁定了，获取这个对象锁的线程就可以去执行一些任务。

在这里插入图片描述
这时候万一有其他线程也想要获取这个对象，此时其他的线程将会自旋等待。

5.3.2 自旋

可以理解为轮询。线程自己在不断地循环去尝试着看一下目标对象的锁有没有被释放。如果释放了，那么就去获取。如果没有释放，那么就进入下一个循环。

这种方式区别于被操作系统挂起阻塞，因为如果对象的锁很快就会被释放的话，自旋就不需要进行系统中断和现场恢复。所以它的效率更高。

自旋相当于CPU在空转。如果长时间自旋将会浪费CPU资源，于是出现了一种叫做“适应性自旋”的优化。

简单来说，就是自旋的时间不再固定，而是由上一次在同一个锁上的自旋时间以及锁状态，这两个条件进行决定的。

举个例子，比如说在同一个锁上，当前正在自旋等待的线程刚刚已经成功获得过锁。但是锁目前是被其他线程占用。那么虚拟机就会认为这次自旋也很有可能会再次成功。进而它将允许更长的自旋时间。这就是适应性自旋。

假如此时有一个线程正在进行自旋，那么这个线程将会进行等待。如果同时有多个线程想要获得这个对象锁。也就是说一旦自旋等待的线程超过1个，那么轻量级锁将会升级为重量级锁。

在这里插入图片描述

5.4 重量级锁

需要通过Monitor来对线程进行控制。此时将会完全锁定资源，对线程的管控也最为严格。

触发条件：轻量级锁自旋失败（竞争激烈）。
原理：

依赖操作系统互斥量（Mutex）实现线程阻塞。
线程进入内核态，由操作系统调度。

缺点：上下文切换开销大。

5.5 锁升级的注意事项

偏向锁延迟： JVM默认启用偏向锁（-XX:+UseBiasedLocking），但启动后4秒才激活（-XX:BiasedLockingStartupDelay=0可禁用延迟）。
锁降级：重量级锁不会降级，但偏向锁可能重置为无锁（调用hashCode()会禁用偏向锁）。
性能影响：
单线程：偏向锁最优。
低竞争：轻量级锁（自旋）。
高竞争：重量级锁（避免CPU空转）。