当前位置：首页 > 文章列表 > 文章 > java教程 > ReentrantLock线程同步实战详解

ReentrantLock线程同步实战详解

2026-05-10 13:24:45 0浏览收藏

本文深入浅出地讲解了Java中ReentrantLock这一强大而灵活的线程同步工具，对比synchronized突出其手动加锁释放、可中断等待、超时获取、公平性控制以及基于Condition的多条件精准通知等核心优势，并通过计数器、限时操作、公平锁配置和生产者-消费者模型等实战示例，手把手演示如何在真实并发场景中安全高效地使用ReentrantLock解决复杂同步问题——既提升程序响应性与可维护性，又避免死锁与线程饥饿，是每位Java开发者进阶高并发编程不可或缺的实用指南。

在Java中如何使用ReentrantLock实现线程同步_ReentrantLock操作实践指南

Java中的ReentrantLock是java.util.concurrent.locks包下的一个可重入互斥锁，相比synchronized关键字，它提供了更灵活的线程同步控制方式。通过手动加锁和释放锁，开发者可以实现更复杂的同步逻辑，比如尝试获取锁、定时等待锁、可中断锁等。下面详细介绍如何在实际开发中使用ReentrantLock进行线程同步。

ReentrantLock的基本用法

使用ReentrantLock的第一步是创建其实例。通常建议将锁声明为private final字段，以确保线程安全和不可变性。

基本操作流程如下：

创建ReentrantLock对象
在访问临界区前调用lock()方法加锁
执行需要同步的代码
在finally块中调用unlock()方法释放锁

示例如下：

import java.util.concurrent.locks.ReentrantLock;

public class Counter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();  // 获取锁
        try {
            count++;
        } finally {
            lock.unlock();  // 释放锁
        }
    }

    public int getCount() {
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
}

注意：unlock()必须放在finally块中，确保即使发生异常也能释放锁，避免死锁。

带超时的锁获取（tryLock）

ReentrantLock支持非阻塞或限时等待获取锁，这在避免死锁或提升响应性方面非常有用。

tryLock()方法有两种形式：

tryLock()：立即返回，成功获取锁返回true，否则返回false
tryLock(long timeout, TimeUnit unit)：在指定时间内尝试获取锁，期间可被中断

示例：限制等待锁的时间

public boolean timedIncrement() {
    boolean acquired = false;
    try {
        acquired = lock.tryLock(1, TimeUnit.SECONDS);
        if (acquired) {
            count++;
            return true;
        } else {
            System.out.println("未能在1秒内获取锁");
            return false;
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return false;
    } finally {
        if (acquired) {
            lock.unlock();
        }
    }
}

这种方式适合对响应时间敏感的场景，比如高并发服务接口。

公平锁与非公平锁

ReentrantLock支持构造公平锁。默认情况下是非公平锁，即线程抢占式获取锁，效率高但可能造成某些线程长期等待。

如果希望线程按请求顺序获取锁，可在构造时传入true：

private final ReentrantLock fairLock = new ReentrantLock(true); // 公平锁

公平锁能减少线程饥饿问题，但性能开销略大，因为需要维护等待队列。应根据实际场景权衡选择。

结合Condition实现等待/通知机制

ReentrantLock配合Condition接口可替代Object的wait/notify机制，实现更精细的线程通信。

Condition允许创建多个等待条件，每个Condition对应一个等待队列。

示例：生产者-消费者模型

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedQueue<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int maxSize;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public BoundedQueue(int size) {
        this.maxSize = size;
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == maxSize) {
                notFull.await(); // 等待队列不满
            }
            queue.offer(item);
            notEmpty.signal(); // 通知消费者
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await(); // 等待队列不空
            }
            T item = queue.poll();
            notFull.signal(); // 通知生产者
            return item;
        } finally {
            lock.unlock();
        }
    }
}

使用Condition的好处是可以针对不同条件独立等待和唤醒，比synchronized更灵活。

基本上就这些。ReentrantLock提供了比synchronized更强大的功能，但也要求开发者更加小心地管理锁的获取与释放。只要遵循“加锁后务必释放”的原则，并合理利用tryLock和Condition，就能写出高效且安全的并发程序。

理论要掌握，实操不能落！以上关于《ReentrantLock线程同步实战详解》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！