Java 线程同步-04：lock 机制

Ne0inhk

— 10 min read

前言

Java的Lock机制是Java并发编程（JDK 1.5+）中用于控制多个线程访问共享资源的核心工具。它位于java.util.concurrent.locks包下，提供了比传统的synchronized关键字更灵活、更强大的锁定操作。

本文主要介绍以 ReentrantLock 和 ReentrantReadWriteLock 为代表的lock机制，文章内容包含一下几个：Java Lock 类继承关系、Lock 使用代码示例、Lock 原理。

类结构

Java的lock机制源头可以从Lock接口说起，这是lock机制的抽象类，规定了锁的相关协议，它定义了锁的获取和释放方法。相比于synchronized（隐式获取/释放锁），Lock需要显式地获取和释放锁。

Lock接口核心方法：

public interface Lock { // 1. 基本锁操作 void lock(); void unlock(); // 2. 可中断锁 void lockInterruptibly() throws InterruptedException; // 3. 尝试获取锁 boolean tryLock(); boolean tryLock(long time, TimeUnit unit) throws InterruptedException; // 4. 条件变量 Condition newCondition(); }

Java同步机制里面涉及的接口层主要有下面三个核心接口：

  1. Lock 接口 - 所有锁的顶级接口，定义了 lock()、unlock() 等基本方法
  2. ReadWriteLock 接口 - 读写锁接口，定义了读锁和写锁的获取方法
  3. Condition 接口 - 条件变量接口，用于线程间的等待/通知机制

对上面几个接口类常用的主要有几个实现类：

  1. ReentrantLock：实现了 Lock 接口内部包含 Sync 同步器
  2. ReentrantReadWriteLock：实现了 ReadWriteLock 接口 内部包含 Sync、ReadLock、WriteLock几个内部类
  3. ConditionObject：实现了 Condition 接口，是 AQS 的内部类

简化版继承结构类图UML：

Lock接口

ReentrantLock

ReadLock

WriteLock

ReadWriteLock接口

ReentrantReadWriteLock

Condition接口

ConditionObject

AQS

Sync

ReadWriteSync

FairSync

NonfairSync

详细版继承结构类图UML：

使用方式

ReentrantLock 使用示例

package concurrent; import java.util.concurrent.*; import java.util.concurrent.locks.*; public class ReentrantLockDemo { private final ReentrantLock lock = new ReentrantLock(); private int counter = 0; // 1. 基本 lock() 和 unlock() public void basicLock() { lock.lock(); try { counter++; System.out.println(Thread.currentThread().getName() + " [basicLock] 计数器: " + counter); Thread.sleep(100); // 模拟工作 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { lock.unlock(); } } /** 持锁一段时间，用于配合 lockInterruptibly 演示 */ public void holdLock(long millis) { lock.lock(); try { System.out.println(Thread.currentThread().getName() + " 持有锁 " + millis + "ms"); Thread.sleep(millis); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { lock.unlock(); System.out.println(Thread.currentThread().getName() + " 释放锁"); } } // 2. tryLock(timeout) - 超时尝试获取锁 public void tryLockWithTimeout() { try { if (lock.tryLock(500, TimeUnit.MILLISECONDS)) { try { System.out.println(Thread.currentThread().getName() + " [tryLockTimeout] 在500ms内获取成功"); Thread.sleep(200); // 模拟工作 } finally { lock.unlock(); } } else { System.out.println(Thread.currentThread().getName() + " [tryLockTimeout] 获取超时"); } } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName() + " [tryLockTimeout] 被中断"); Thread.currentThread().interrupt(); } } // 3. lockInterruptibly() - 可中断锁（在等待锁的过程中可被 interrupt 并抛出 InterruptedException） public void lockInterruptiblyExample() throws InterruptedException { System.out.println(Thread.currentThread().getName() + " 尝试 lockInterruptibly()，若锁被占用将阻塞等待..."); lock.lockInterruptibly(); // 阻塞等待期间若被 interrupt，会抛出 InterruptedException try { System.out.println(Thread.currentThread().getName() + " 获取锁成功，执行业务"); Thread.sleep(500); } finally { if (lock.isHeldByCurrentThread()) { lock.unlock(); System.out.println(Thread.currentThread().getName() + " 释放锁"); } } } // 运行 ReentrantLock 所有示例 public static void main(String[] args) throws Exception { System.out.println("\n========== ReentrantLock 示例开始 =========="); ReentrantLockDemo reentrantDemo = new ReentrantLockDemo(); // 1. 基本 lock() 示例 System.out.println("\n1. 基本 lock() 示例:"); Thread t1 = new Thread(() -> reentrantDemo.basicLock(), "Thread-1"); Thread t2 = new Thread(() -> reentrantDemo.basicLock(), "Thread-2"); t1.start(); t2.start(); t1.join(); t2.join(); // 2. tryLock(timeout) 示例 System.out.println("\n2. tryLock(timeout) 示例:"); Thread t5 = new Thread(() -> reentrantDemo.tryLockWithTimeout(), "Thread-5"); Thread t6 = new Thread(() -> reentrantDemo.tryLockWithTimeout(), "Thread-6"); t5.start(); t6.start(); t5.join(); t6.join(); // 3. lockInterruptibly() 示例：先让一个线程持锁，另一个线程在 lockInterruptibly() 上阻塞，再中断阻塞线程 System.out.println("\n3. lockInterruptibly() 示例（在等待锁时被中断）:"); Thread holder = new Thread(() -> reentrantDemo.holdLock(5000), "Holder"); Thread interruptible = new Thread(() -> { try { reentrantDemo.lockInterruptiblyExample(); System.out.println("Interruptible-Thread 正常结束"); } catch (InterruptedException e) { System.out.println("Interruptible-Thread 在等待锁时被中断，抛出 InterruptedException"); Thread.currentThread().interrupt(); } }, "Interruptible-Thread"); holder.start(); Thread.sleep(100); // 确保 Holder 先拿到锁 interruptible.start(); Thread.sleep(800); // 此时 Interruptible 正在 lockInterruptibly() 上阻塞 interruptible.interrupt(); // 中断正在等待锁的线程 interruptible.join(); holder.join(); System.out.println("\n========== ReentrantLock 示例结束 =========="); } }

代码运行结果：

========== ReentrantLock 示例开始 ========== 1. 基本 lock() 示例: Thread-1 [basicLock] 计数器: 1 Thread-2 [basicLock] 计数器: 2 2. tryLock(timeout) 示例: Thread-5 [tryLockTimeout] 在500ms内获取成功 Thread-6 [tryLockTimeout] 在500ms内获取成功 3. lockInterruptibly() 示例（在等待锁时被中断）: Holder 持有锁 5000ms Interruptible-Thread 尝试 lockInterruptibly()，若锁被占用将阻塞等待... Interruptible-Thread 在等待锁时被中断，抛出 InterruptedException Holder 释放锁 ========== ReentrantLock 示例结束 ==========

ReentrantLock 使用示例

package concurrent; import java.util.concurrent.locks.ReentrantReadWriteLock; /** * ReentrantReadWriteLock 使用示例： * - 读锁（readLock）：共享，多线程可同时持有，与写锁互斥 * - 写锁（writeLock）：独占，同一时刻仅一个线程可持有，与读锁、写锁均互斥 */ public class ReentrantReadWriteLockDemo { private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock(); private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock(); private String data = "initial"; // 1. 读锁：多个线程可同时读 public void readWithReadLock() { System.out.println(Thread.currentThread().getName() + " 尝试获取读锁"); readLock.lock(); // 若写锁被占用，会在此阻塞 try { System.out.println(Thread.currentThread().getName() + " 获取到读锁（写锁已释放后才会执行到这里）"); System.out.println(Thread.currentThread().getName() + " [读锁] 读取: " + data); Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { readLock.unlock(); } } // 2. 写锁：独占，同一时刻只有一个线程可写 public void writeWithWriteLock(String newData) { writeLock.lock(); try { System.out.println(Thread.currentThread().getName() + " [写锁] 写入: " + newData); data = newData; Thread.sleep(300); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { writeLock.unlock(); } } // 3. 持写锁一段时间，用于演示读/写互斥 public void holdWriteLock(long millis) { writeLock.lock(); try { System.out.println(Thread.currentThread().getName() + " 持有写锁 " + millis + "ms（此时读锁会阻塞）"); Thread.sleep(millis); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { // 先打印再 unlock，保证控制台顺序能体现：先释放写锁，后读者才拿到读锁 System.out.println(Thread.currentThread().getName() + " 释放写锁"); writeLock.unlock(); } } public static void main(String[] args) throws InterruptedException { ReentrantReadWriteLockDemo demo = new ReentrantReadWriteLockDemo(); System.out.println("========== 1. 读锁共享：多个线程同时读 =========="); Thread r1 = new Thread(() -> demo.readWithReadLock(), "Reader-1"); Thread r2 = new Thread(() -> demo.readWithReadLock(), "Reader-2"); Thread r3 = new Thread(() -> demo.readWithReadLock(), "Reader-3"); r1.start(); r2.start(); r3.start(); r1.join(); r2.join(); r3.join(); System.out.println("\n========== 2. 写锁独占：同一时刻只有一个写 =========="); Thread w1 = new Thread(() -> demo.writeWithWriteLock("A"), "Writer-1"); Thread w2 = new Thread(() -> demo.writeWithWriteLock("B"), "Writer-2"); w1.start(); w2.start(); w1.join(); w2.join(); System.out.println("\n========== 3. 读与写互斥：写锁持有时，读锁阻塞 =========="); Thread holder = new Thread(() -> demo.holdWriteLock(2000), "Writer-Holder"); Thread reader = new Thread(() -> demo.readWithReadLock(), "Reader-Blocked"); holder.start(); Thread.sleep(100); reader.start(); holder.join(); reader.join(); System.out.println("\n========== ReentrantReadWriteLock 示例结束 =========="); } }

代码运行结果：

========== 1. 读锁共享：多个线程同时读 ========== Reader-1 尝试获取读锁 Reader-2 尝试获取读锁 Reader-3 尝试获取读锁 Reader-1 获取到读锁（写锁已释放后才会执行到这里） Reader-2 获取到读锁（写锁已释放后才会执行到这里） Reader-3 获取到读锁（写锁已释放后才会执行到这里） Reader-1 [读锁] 读取: initial Reader-3 [读锁] 读取: initial Reader-2 [读锁] 读取: initial ========== 2. 写锁独占：同一时刻只有一个写 ========== Writer-1 [写锁] 写入: A Writer-2 [写锁] 写入: B ========== 3. 读与写互斥：写锁持有时，读锁阻塞 ========== Writer-Holder 持有写锁 2000ms（此时读锁会阻塞） Reader-Blocked 尝试获取读锁 Writer-Holder 释放写锁 Reader-Blocked 获取到读锁（写锁已释放后才会执行到这里） Reader-Blocked [读锁] 读取: B ========== ReentrantReadWriteLock 示例结束 ==========

Lock 原理

Java lock机制使用AQS来管理锁的状态，进而管理同步锁的获取和释放。

使用AQS管理锁状态

AQS (AbstractQueuedSynchronizer) 是一个抽象接口，核心代码如下：

// AQS 简化实现原理 public abstract class AbstractQueuedSynchronizer { // 核心字段1: 同步状态（32位int） private volatile int state; // 核心字段2: CLH队列（双向链表） private transient volatile Node head; // 队列头 private transient volatile Node tail; // 队列尾 // 队列节点 static final class Node { volatile Node prev; // 前驱节点 volatile Node next; // 后继节点 volatile Thread thread; // 等待的线程 volatile int waitStatus; // 等待状态 Node nextWaiter; // 条件队列使用 } // 核心方法：CAS操作 protected final boolean compareAndSetState(int expect, int update) { return unsafe.compareAndSwapInt(this, stateOffset, expect, update); } }

ReentrantLock 使用 AQS 的 state 字段表示锁状态，类内部存在一个Sync内部类：

// ReentrantLock 使用 AQS 的 state 字段表示锁状态 public class ReentrantLock { abstract static class Sync extends AbstractQueuedSynchronizer { // state 含义: // 0: 无锁状态 // 1: 有线程持有锁（非重入） // N: 同一个线程重入了 N-1 次 } }

基于lock获取同步锁时，会经历以下流程：

是

否

是

是

无

有

否

成功

失败

否

线程尝试获取锁

是否持有锁?

重入计数+1

state是否为0?

公平锁?

有前驱节点?

CAS获取锁

入队等待

直接CAS尝试

获取成功

获取成功

进入CLH队列

自旋或挂起

被唤醒后尝试

这里内部类Sync实现主要有公平锁和非公平锁两种实现，本文不展开深入，可看下篇文章。另外，这里涉及到的CLH 队列是一种自旋锁的等待队列实现，全称为 Craig, Landin, and Hagersten queue，是 AQS（AbstractQueuedSynchronizer）中实现线程排队等待的核心数据结构。

读写锁获取的实现

读写锁这里用到了state字段做了些状态设计：

static class Sync extends AbstractQueuedSynchronizer { // 使用 state 的高16位表示读锁数量，低16位表示写锁重入次数 // state = (读锁数量 << 16) | 写锁重入次数 static final int SHARED_SHIFT = 16; static final int SHARED_UNIT = (1 << SHARED_SHIFT); // 读锁单位: 65536 static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1; // 最大计数: 65535 static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1; // 写锁掩码: 0xFFFF // 获取读锁数量 static int sharedCount(int c) { return c >>> SHARED_SHIFT; } // 获取写锁重入次数 static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; } }

写锁获取的核心方法如下：

// WriteLock 的 tryAcquire 方法 protected final boolean tryAcquire(int acquires) { Thread current = Thread.currentThread(); int c = getState(); int w = exclusiveCount(c); // 获取写锁数量 if (c != 0) { // 有锁被持有 // 情况1: 有读锁 (w == 0 但 c != 0) // 情况2: 有写锁但不是当前线程持有 (w != 0 && 持有者 != current) if (w == 0 || current != getExclusiveOwnerThread()) return false; // 获取失败 // 情况3: 当前线程持有写锁（重入） if (w + exclusiveCount(acquires) > MAX_COUNT) throw new Error("Maximum lock count exceeded"); setState(c + acquires); return true; } // c == 0 无锁状态 if (writerShouldBlock() || // 公平性检查 !compareAndSetState(c, c + acquires)) return false; setExclusiveOwnerThread(current); return true; }

读锁获取核心方法如下：

// ReadLock 的 tryAcquireShared 方法 protected final int tryAcquireShared(int unused) { Thread current = Thread.currentThread(); int c = getState(); // 如果有写锁，并且不是当前线程持有的 if (exclusiveCount(c) != 0 && getExclusiveOwnerThread() != current) return -1; // 获取失败 int r = sharedCount(c); // 当前读锁数量 // 检查是否应该阻塞（公平性检查） if (!readerShouldBlock() && r < MAX_COUNT && compareAndSetState(c, c + SHARED_UNIT)) { // 第一个读锁 if (r == 0) { firstReader = current; firstReaderHoldCount = 1; } // 当前线程是第一个读锁持有者 else if (firstReader == current) { firstReaderHoldCount++; } // 其他线程持有读锁 else { HoldCounter rh = cachedHoldCounter; if (rh == null || rh.tid != current.getId()) cachedHoldCounter = rh = readHolds.get(); else if (rh.count == 0) readHolds.set(rh); rh.count++; } return 1; // 获取成功 } // CAS失败或应该阻塞，进入完整获取流程 return fullTryAcquireShared(current); }

Read more

使用ros2跑mid360的fastlio2算法详细教程

1、ROS2-Humble系统要求使用Ubuntu 22.04版本，所以需要先安装虚拟机。ubuntu镜像可以从这里下载：ubuntu-releases-22.04安装包下载_开源镜像站-阿里云 2、安装完Ubuntu后进入系统，按照ROS2的官方文档安装Humble版本：Ubuntu (deb packages) — ROS 2 Documentation: Humble documentation 3、编译并安装Livox-mid360的驱动库：Livox-SDK/Livox-SDK2: Drivers for receiving LiDAR data and controlling lidar, support Lidar HAP and Mid-360. 第一步： * 先安装CMAKE库$ sudo apt install cmake *  然后$ gcc -v 确认一下gcc版本大于4.8.1 * 执行如下命令克隆、
Flutter 三方库 matcher 的鸿蒙化适配指南 - 实现具备语义化断言与自定义匹配算法的测试契约框架、支持端侧质量验证的强力抽象实战

Flutter 三方库 matcher 的鸿蒙化适配指南 - 实现具备语义化断言与自定义匹配算法的测试契约框架、支持端侧质量验证的强力抽象实战

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net Flutter 三方库 matcher 的鸿蒙化适配指南 - 实现具备语义化断言与自定义匹配算法的测试契约框架、支持端侧质量验证的强力抽象实战 前言 在进行 Flutter for OpenHarmony 开发时，当编写单元测试时，我们经常使用 expect(actual, matcher) 这种语法。你是否想过，如何让断言读起来像自然语言一样？或者，如何自定义一套专门针对鸿蒙原生组件状态的对比逻辑？matcher 是 Dart 官方维护的断言库扩展，它定义了测试中所有“匹配逻辑”的底层协议。本文将探讨如何在鸿蒙端构建极致、严谨的质量契约体系。 一、原直观解析 / 概念介绍 1.1 基础原理 该库建立在“谓词逻辑（Predicate Logic）”之上。它通过将复杂的 Object
【算法通关指南：数据结构与算法篇】二叉树相关算法题：1.美国血统 American Heritage 2.二叉树问题

【算法通关指南：数据结构与算法篇】二叉树相关算法题：1.美国血统 American Heritage 2.二叉树问题

🔥小龙报：个人主页 🎬作者简介：C++研发，嵌入式，机器人方向学习者 ❄️个人专栏：《算法通关指南》 ✨ 永远相信美好的事情即将发生 文章目录 * 前言 * 一、美国血统 American Heritage * 1.1题目 * 1.2 算法原理 * 1.3代码 * 二、 二叉树问题 * 2.1题目 * 2.2 算法原理 * 2.3代码 * 总结与每日励志 前言 本专栏聚焦算法题实战，系统讲解算法模块：以《c++编程》，《数据结构和算法》《基础算法》《算法实战》 等几个板块以题带点，讲解思路与代码实现，帮助大家快速提升代码能力ps:本章节题目分两部分，比较基础笔者只附上代码供大家参考，其他的笔者会附上自己的思考和讲解，希望和大家一起努力见证自己的算法成长 一、
Flutter 三方库 music_notes 跨栈极客音乐教学底层核心算法鸿蒙化适配解析：高保真重组异度乐理参数体系精准切割动态音程和弦算子推进数字化编曲演进-适配鸿蒙 HarmonyOS ohos

Flutter 三方库 music_notes 跨栈极客音乐教学底层核心算法鸿蒙化适配解析：高保真重组异度乐理参数体系精准切割动态音程和弦算子推进数字化编曲演进-适配鸿蒙 HarmonyOS ohos

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.ZEEKLOG.net Flutter 三方库 music_notes 跨栈极客音乐教学底层核心算法鸿蒙化适配解析：高保真重组异度乐理参数体系精准切割动态音程和弦算子推进数字化编曲演进大盘 在鸿蒙平台的数字音乐创作、智慧钢琴教学或音频编辑工具的开发中，如何通过代码精确表达音高（Pitch）、调性（Key）与和弦（Chord）逻辑？music_notes 库是一套专为乐理计算设计的 Dart 核心工具库。本文将详解该库在 OpenHarmony 上的适配要点。 前言 什么是 music_notes？它不仅能简单地表示音符。还内置了复杂的半音/全音步长运算、调号（Key Signatures）转换以及音程（Intervals）关系判定。在鸿蒙操作系统强调的“全场景智慧办公”和“极致影音娱乐”背景下，利用 music_notes 库可以确保你的应用在面对复杂的乐谱解析、