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

殷紫川
0 阅读4分钟

在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();
    }
}

最佳实践

  1. 锁的释放必须在finally块，避免异常导致锁未释放。
  2. 优先使用非公平锁，除非业务必须保证公平性。
  3. 使用可中断锁时，正确处理InterruptedException，恢复中断状态。
  4. 避免锁的嵌套，防止死锁。
  5. 合理设置锁的粒度，避免锁范围过大影响性能。
avatar
文章
阅读
粉丝