lockInterruptibly 和 lock

最新推荐文章于 2025-06-13 16:03:30 发布

最新推荐文章于 2025-06-13 16:03:30 发布 · 396 阅读

文章标签：

#lockInterruptibly #lock #ReentrantLock

JAVA 基础专栏收录该内容

42 篇文章

订阅专栏

本文通过一个生动的例子介绍了ReentrantLock中的lockInterruptibly方法的特点。该方法允许在未获取到锁的情况下响应中断请求，这对于实现可中断的等待逻辑非常有用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.序言

ReentrantLock 锁有好几种，除了常用的lock tryLock 等意外，其中有个lockInterruptibly 用的比较少，看了下JDK 说明，官方的东西总是那么不容易理解，这里用稍微通俗的语言来描述一下。

二.栗子

1.我们用张三和李四吃水果来描述：

如果张三吃苹果->休息5秒->吃香蕉

李四：发现张三在吃，就等待，直到李四吃完

import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by qqr on 15/5/17.
 */
public class Lock {


    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new TaskThread());
        t1.setName("张三 ");
        Thread t2  = new Thread(new TaskThread());
        t2.setName("李四 ");
        t1.start();
        Thread.sleep(100);// 保证先后顺序

        t2.start();
        Thread.sleep(100);
        // 中断
        t2.interrupt();


    }


    static class TaskThread implements Runnable{
        // 所有线程都用同一把锁
        static ReentrantLock lock = new ReentrantLock();

        @Override
        public void run() {

            try {
                // 
                lock.lockInterruptibly();
                System.out.println(Thread.currentThread().getName() + " 吃苹果");

                Thread.sleep(5 * 1000);

                System.out.println(Thread.currentThread().getName() + " 吃香蕉");
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " 被中断了，没吃了");
            }finally {
                lock.unlock();
            }

        }

    }
}

返回结果是：

张三  吃苹果
张三  吃香蕉
李四  吃苹果
李四  被中断了，没吃了

第一次如果用 lock() ，那么就是正常的逻辑：

张三持有锁的时候，李四没有获得锁，打断效果也会阻塞着，等张三吃完，李四吃苹果，然后被打断，就是上面结果了。

如果换成lockInterruptibly,那么结果是：

张三  吃苹果
李四  被中断了，没吃了
Exception in thread "李四 " java.lang.IllegalMonitorStateException
张三  吃香蕉

我们会发现，即使李四没有获得锁，也是可以被打断的，这个区别是很明显的。

在linkedBlockingQuene 的put/take 方法中，我们可以看到类似这样的代码：

public void put(E e) throws InterruptedException {
        // ....
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        putLock.lockInterruptibly();
        try {
           while (count.get() == capacity) {
                notFull.await();
            }
            // ....
       }
}

最为加锁的阻塞队列，这里不允许多线程同时put，多线程对进入等待，但是用了lockInterruptibly，那么就意味着可以中断那些等待着的线程

四.小结

1.这里仅仅简单理解下他效果，可能并不全

2.遇到其他的场景或者解释有问题，请分享和指出，谢谢。