如何为解决并发问题后的ReentrantLock锁设置超时时间？

嘿，很高兴看到你已经用ReentrantLock搞定了线程并发操作全局变量X的问题！要给这个锁加上超时功能其实非常直观——ReentrantLock本身就提供了带超时的锁获取方法，完全不用额外造轮子，下面我给你一步步讲清楚怎么改：

核心方法：tryLock(long timeout, TimeUnit unit) #

原来你用的lock()方法是无限阻塞直到拿到锁，而tryLock(long timeout, TimeUnit unit)会在指定的时间范围内尝试获取锁：

• 如果在超时前成功拿到锁，返回true，你就可以安全执行操作X的逻辑；
• 如果超时后还是没拿到锁，返回false，这时候你可以根据业务需求做降级处理（比如打日志、跳过本次操作或者重试）。

改造后的代码示例 #

我把你原来的锁逻辑改成带超时的版本，你可以直接参考：

// 先定义好锁和全局变量X
private static ReentrantLock lock = new ReentrantLock();
private static int X = 0;

// ThreadA的加1逻辑（带超时）
class ThreadA extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            boolean gotLock = false;
            try {
                // 尝试在500毫秒内获取锁，时间单位可以按需调整（比如SECONDS、MILLISECONDS）
                gotLock = lock.tryLock(500, TimeUnit.MILLISECONDS);
                if (gotLock) {
                    X++;
                    System.out.println(X);
                } else {
                    // 超时没拿到锁的处理逻辑，比如记录日志
                    System.err.println("ThreadA获取锁超时，跳过本次加1操作");
                }
            } catch (InterruptedException e) {
                // 处理线程中断异常，建议恢复中断状态
                Thread.currentThread().interrupt();
                System.err.println("ThreadA获取锁时被中断");
            } finally {
                // 只有成功拿到锁才释放，避免非法释放锁的异常
                if (gotLock) {
                    lock.unlock();
                }
            }
        }
    }
}

// ThreadB的乘2逻辑（带超时）
class ThreadB extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 2; i++) {
            boolean gotLock = false;
            try {
                gotLock = lock.tryLock(1, TimeUnit.SECONDS);
                if (gotLock) {
                    X *= 2;
                    System.out.println(X);
                } else {
                    System.err.println("ThreadB获取锁超时，跳过本次乘2操作");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.err.println("ThreadB获取锁时被中断");
            } finally {
                if (gotLock) {
                    lock.unlock();
                }
            }
        }
    }
}

关键注意事项 #

• 必须判断锁是否获取成功再释放：如果直接在finally里调用unlock()，当tryLock返回false时，当前线程不是锁的持有者，会抛出IllegalMonitorStateException，所以一定要用gotLock变量做判断。
• 处理中断异常：tryLock会响应线程中断，所以必须捕获InterruptedException，并且建议调用Thread.currentThread().interrupt()恢复线程的中断状态——中断状态是线程的重要标识，不要轻易吞掉。
• 超时时间的选择：根据你的业务场景调整超时时长，如果操作X的逻辑很快，超时时间可以设短一点（比如几百毫秒）；如果逻辑复杂，就适当延长。
• 可选的重试逻辑：如果业务不允许跳过操作，你可以在tryLock返回false后加个循环重试，但要注意控制重试次数，避免无限循环导致CPU占用过高。

这样改造后，你的线程在获取锁时就不会无限等待，一旦超时就会触发你定义的降级逻辑，既保证了并发安全，又增加了系统的容错性。

内容的提问来源于stack exchange，提问作者O. Kumru