Java并发编程之ReentrantLock_reentrantlock 超时-优快云博客

一、可中断锁

1. 核心方法：`lockInterruptibly()`

作用：允许线程在等待锁的过程中响应中断请求。
适用场景：需要支持任务取消或中断的同步操作（如用户手动取消长时间等待的任务）。

2. 代码示例

ReentrantLock lock = new ReentrantLock();

Thread thread = new Thread(() -> {
    try {
        lock.lockInterruptibly(); // 可中断获取锁
        try {
            System.out.println("线程获取锁并执行任务");
            Thread.sleep(5000); // 模拟耗时操作
        } finally {
            lock.unlock();
        }
    } catch (InterruptedException e) {
        System.out.println("线程被中断，放弃获取锁");
    }
});

lock.lock(); // 主线程先获取锁
try {
    thread.start();
    Thread.sleep(1000); // 确保子线程开始等待锁
    thread.interrupt(); // 中断子线程
} finally {
    lock.unlock();
}

3. 行为分析

未中断时：线程正常获取锁并执行任务。
中断时：抛出 InterruptedException，线程退出等待队列。

二、锁超时

1. 核心方法：`tryLock()`

无参方法：boolean tryLock()
立即尝试获取锁，成功返回 true，失败返回 false。
带超时方法：boolean tryLock(long timeout, TimeUnit unit)
在指定时间内尝试获取锁，超时后放弃。

2. 代码示例：避免死锁

ReentrantLock lockA = new ReentrantLock();
ReentrantLock lockB = new ReentrantLock();

Thread thread1 = new Thread(() -> {
    try {
        if (lockA.tryLock(1, TimeUnit.SECONDS)) { // 尝试获取lockA
            try {
                if (lockB.tryLock(1, TimeUnit.SECONDS)) { // 尝试获取lockB
                    System.out.println("Thread1完成任务");
                }
            } finally {
                if (lockB.isHeldByCurrentThread()) lockB.unlock();
            }
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (lockA.isHeldByCurrentThread()) lockA.unlock();
    }
});

Thread thread2 = new Thread(() -> { /* 类似逻辑，先尝试lockB再lockA */ });
thread1.start();
thread2.start();

3. 应用场景

死锁预防：通过超时放弃锁请求，打破循环等待。
响应性优化：避免线程长时间阻塞影响系统响应速度。

三、条件变量

1. 核心机制

创建条件变量：Condition condition = lock.newCondition();
等待条件：condition.await();
唤醒线程：condition.signal() 或 condition.signalAll()

2. 代码示例：生产者-消费者模型

ReentrantLock lock = new ReentrantLock();
Condition notEmpty = lock.newCondition(); // 非空条件
Condition notFull = lock.newCondition();  // 非满条件
Queue<Integer> queue = new LinkedList<>();
int maxSize = 10;

// 生产者
new Thread(() -> {
    lock.lock();
    try {
        while (queue.size() == maxSize) {
            notFull.await(); // 等待队列非满
        }
        queue.add(1);
        notEmpty.signal(); // 通知消费者
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}).start();

// 消费者
new Thread(() -> {
    lock.lock();
    try {
        while (queue.isEmpty()) {
            notEmpty.await(); // 等待队列非空
        }
        queue.poll();
        notFull.signal(); // 通知生产者
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }
}).start();

3. 优势对比 `wait()/notify()`

特性	`Condition`	`wait()/notify()`
多条件支持	✅ 可创建多个条件变量	❌ 每个对象仅一个等待队列
精准唤醒	✅ `signal()` 唤醒指定条件队列的线程	❌ `notify()` 随机唤醒