ReentrantLock锁的使用与详解

**ReentrantLock详解：Java并发编程中的锁利器** 在Java并发编程中，`ReentrantLock`作为`java.util.concurrent.locks`包下的重要组成部分，提供了比`synchronized`关键字更为强大和灵活的锁机制。本文将深入探讨`ReentrantLock`的使用方法，包括其基本用法、可重入特性、公平锁与非公平锁的选择、`tryLock`的妙用以及中断响应机制。通过具体代码示例，详细讲解如何利用`ReentrantLock`实现线程同步，并强调在`finally`块中释放锁的重要性，以避免死锁的发生。掌握`ReentrantLock`，让您在复杂的并发场景中游刃有余，编写出高效、稳定的多线程程序。

ReentrantLock提供比synchronized更灵活的锁控制，支持手动加锁释放、可重入、公平锁、tryLock及中断响应机制，需始终在finally中unlock避免死锁。

在Java中，ReentrantLock 是 java.util.concurrent.locks 包提供的一个可重入的互斥锁，它提供了比 synchronized 更灵活的锁操作。相比 synchronized 关键字，ReentrantLock 支持手动加锁和释放锁、可中断等待、超时获取锁、公平锁等特性。

1. 基本使用方法

使用 ReentrantLock 实现同步，需要显式地调用 lock() 和 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();  // 释放锁（必须放在 finally 中）
        }
    }

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

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

2. 可重入性

ReentrantLock 是可重入锁，同一个线程可以多次获取同一把锁。

例如：

public void methodA() {
    lock.lock();
    try {
        System.out.println("methodA");
        methodB();  // 同一线程再次进入，不会阻塞
    } finally {
        lock.unlock();
    }
}

public void methodB() {
    lock.lock();
    try {
        System.out.println("methodB");
    } finally {
        lock.unlock();
    }
}

由于是可重入的，线程在持有锁的情况下再次请求该锁时会成功，计数器+1；每次 unlock() 计数器-1，直到为0才真正释放锁。

3. 公平锁与非公平锁

创建 ReentrantLock 时可以指定是否为公平锁：

• new ReentrantLock()：默认是非公平锁（性能更高）
• new ReentrantLock(true)：构造公平锁（先等待的线程优先获取锁）

公平锁能减少“线程饥饿”，但吞吐量较低。

4. 尝试获取锁（tryLock）

使用 tryLock() 可以尝试获取锁，如果无法获取立即返回 false，避免无限等待。

if (lock.tryLock()) {
    try {
        // 执行临界区操作
    } finally {
        lock.unlock();
    }
} else {
    // 锁被占用，执行其他逻辑
    System.out.println("无法获取锁，跳过...");
}

也可以设置超时时间：

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // 成功获取锁
    } finally {
        lock.unlock();
    }
} else {
    // 超时未获取到锁
}

5. 中断响应

使用 lockInterruptibly() 可以使等待锁的线程响应中断。

public void interruptibleMethod() throws InterruptedException {
    lock.lockInterruptibly();  // 可中断的锁获取
    try {
        // 执行操作
    } finally {
        lock.unlock();
    }
}

当其他线程调用该线程的 interrupt() 方法时，会抛出 InterruptedException，提前终止等待。

基本上就这些。ReentrantLock 提供了更细粒度的控制，适合复杂并发场景。关键是记得始终在 finally 中释放锁，避免资源泄漏。

以上就是《ReentrantLock锁的使用与详解》的详细内容，更多关于的资料请关注golang学习网公众号！