在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();
}
}
最佳实践
- 锁的释放必须在finally块，避免异常导致锁未释放。
- 优先使用非公平锁，除非业务必须保证公平性。
- 使用可中断锁时，正确处理InterruptedException，恢复中断状态。
- 避免锁的嵌套，防止死锁。
- 合理设置锁的粒度，避免锁范围过大影响性能。
