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

ReentrantLock提供比synchronized更灵活的线程同步控制，支持手动加锁释放、尝试获取锁、定时等待、可中断及公平锁机制，并可通过Condition实现多条件等待通知，适用于复杂并发场景。

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 {
    private final Queue 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，就能写出高效且安全的并发程序。