当前位置：首页 > news >正文

深入拆解 ReentrantLock：从底层实现到生产最佳实践

news 2026/7/30 8:54:37

在Java并发编程中，锁是保证线程安全的核心工具。ReentrantLock作为JUC包下的显式锁，相比内置的synchronized，提供了更灵活的功能。本文将从底层实现原理出发，全面剖析ReentrantLock的核心机制，对比其与synchronized的差异，并结合实际场景讲解公平锁、非公平锁、可中断锁的使用与最佳实践。

ReentrantLock的底层实现原理

ReentrantLock的核心基于AbstractQueuedSynchronizer（AQS）实现。AQS是一个用于构建锁和同步器的框架，通过一个volatile修饰的int类型state变量表示同步状态，以及一个FIFO的双向队列（CLH队列）管理等待的线程。

AQS核心结构

state：同步状态，0表示无锁，大于0表示持有锁的次数（可重入）。
等待队列：双向链表，每个节点封装一个Thread，记录等待状态。

非公平锁的lock流程

从源码层面看，ReentrantLock的NonfairSync的lock方法逻辑如下：

final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); }

acquire方法会调用tryAcquire，NonfairSync的tryAcquire最终调用nonfairTryAcquire：

final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }

这里体现了可重入特性：如果当前线程已经持有锁，直接增加state值即可。

释放锁的unlock流程

unlock会调用release(1)，核心逻辑在tryRelease：

protected final boolean tryRelease(int releases) { int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; }

当state减到0时，锁完全释放，唤醒等待队列中的头节点后继线程。

公平锁的实现

FairSync的tryAcquire与非公平锁的核心差异在于多了hasQueuedPredecessors()判断：

protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }

hasQueuedPredecessors()会判断当前线程是否有前驱节点在等待队列中，如果有则必须入队，以此保证公平性。

ReentrantLock与synchronized的核心差异

实现层面

synchronized：JVM内置锁，通过对象头的Mark Word和monitorenter/monitorexit指令实现，包含锁升级过程（无锁->偏向锁->轻量级锁->重量级锁）。
ReentrantLock：JDK实现的显式锁，基于AQS框架，需要手动调用lock()和unlock()。

功能层面

可重入：两者都支持，ReentrantLock可通过getHoldCount()查看重入次数，synchronized由JVM内部管理。
公平性：ReentrantLock支持公平/非公平两种模式，synchronized只有非公平模式。
可中断：ReentrantLock的lockInterruptibly()支持等待时响应中断，synchronized不支持。
条件变量：ReentrantLock可创建多个Condition实现更灵活的等待/通知，synchronized只有一个wait set。

性能层面

JDK6后synchronized通过锁升级优化，性能与ReentrantLock接近。高竞争场景下，ReentrantLock的非公平锁可能比synchronized吞吐量更高，因为非公平锁可以减少线程切换开销。

公平锁、非公平锁、可中断锁的适用场景与最佳实践

公平锁

适用场景：需要保证线程获取锁的顺序，比如按请求顺序处理任务，避免线程饥饿。注意：公平锁会降低吞吐量，因为每次都要检查队列，增加线程切换。

package com.jam.demo; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.locks.ReentrantLock; @Slf4j public class FairLockDemo { private final ReentrantLock fairLock = new ReentrantLock(true); public void accessResource() { fairLock.lock(); try { log.info("线程{}获取到公平锁", Thread.currentThread().getName()); Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); log.error("线程被中断", e); } finally { fairLock.unlock(); log.info("线程{}释放公平锁", Thread.currentThread().getName()); } } public static void main(String[] args) { FairLockDemo demo = new FairLockDemo(); for (int i = 0; i < 5; i++) { new Thread(demo::accessResource, "Thread-" + i).start(); } } }

非公平锁

适用场景：大多数场景，追求高吞吐量，线程执行时间短，饥饿概率低。优势：线程可以“插队”获取锁，减少线程唤醒的开销。

package com.jam.demo; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.locks.ReentrantLock; @Slf4j public class NonfairLockDemo { private final ReentrantLock nonfairLock = new ReentrantLock(false); public void accessResource() { nonfairLock.lock(); try { log.info("线程{}获取到非公平锁", Thread.currentThread().getName()); Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); log.error("线程被中断", e); } finally { nonfairLock.unlock(); log.info("线程{}释放非公平锁", Thread.currentThread().getName()); } } public static void main(String[] args) { NonfairLockDemo demo = new NonfairLockDemo(); for (int i = 0; i < 5; i++) { new Thread(demo::accessResource, "Thread-" + i).start(); } } }

可中断锁

适用场景：需要取消长时间等待锁的任务，比如超时控制，避免死锁时无限等待。使用：调用lockInterruptibly()，等待时可响应interrupt()。

package com.jam.demo; import lombok.extern.slf4j.Slf4j; import java.util.concurrent.locks.ReentrantLock; @Slf4j public class InterruptibleLockDemo { private final ReentrantLock lock = new ReentrantLock(); public void accessResource() { try { lock.lockInterruptibly(); try { log.info("线程{}获取到锁", Thread.currentThread().getName()); Thread.sleep(5000); } finally { lock.unlock(); log.info("线程{}释放锁", Thread.currentThread().getName()); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); log.info("线程{}等待锁时被中断", Thread.currentThread().getName()); } } public static void main(String[] args) throws InterruptedException { InterruptibleLockDemo demo = new InterruptibleLockDemo(); Thread t1 = new Thread(demo::accessResource, "Thread-1"); Thread t2 = new Thread(demo::accessResource, "Thread-2"); t1.start(); Thread.sleep(100); t2.start(); Thread.sleep(1000); t2.interrupt(); } }