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

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

从源码层面看，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会调用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的核心差异

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

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

本文深入剖析ReentrantLock底层原理，基于AQS框架详解state状态、CLH队列及公平/非公平锁机制；对比synchronized在实现、功能（可中断、多条件变量）和性能上的差异；结合代码演示三类锁适用场景与最佳实践，助你写出高效、健壮的并发程序。

人工智能

深入解析Java并发编程中的ReentrantLock实现原理与使用技巧，对比synchronized差异，详解公平锁、非公平锁和可中断锁的底层机制与最佳实践，帮助开发者提升多线程编程能力。

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

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

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

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐