四、LockSupport与线程中断

最新推荐文章于 2023-05-07 13:09:20 发布
最新推荐文章于 2023-05-07 13:09:20 发布
阅读量410 收藏 2
点赞数 1
分类专栏： JUC 文章标签： 线程中断机制 LockSupport Condition接口
余笙
本文链接：https://blog.youkuaiyun.com/qq_42200163/article/details/126474290
版权

一、线程中断机制

1、什么是中断

1、中断可以理解为线程的一个标志位，它表示了一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了一个招呼，其他线程通过调用该线程的interrupt方法对其进行中断操作，同时该线程可以调用isInterrupted来感知其他线程对其自身的中断操作，从而做出响应。
2、调用interrupt方法仅仅是将线程对象的中断标识设置成true，每个线程对象中都有一个中断标识位，用于表示线程是否被中断，该标识位true表示中断，false表示未中断。
3、另外，同样可以调用Thread的静态方法interrupted对当前线程进行中断操作，该方法会清除中断标志位。
3、注意：当抛出InterruptedException的时候，会清除中断标志位，也就是说在调用isInterrupted会返回fasle。

2、中断的相关方法

1、public void interrupt()：仅仅是设置线程的中断状态为true，不会停止线程，需要注意如下两点：
  • 当对一个线程调用interrupt方法时，如果被打断线程处于被阻塞状态（如：sleep、wait、join等状态），会导致被打断的线程抛出InterruptedException，退出被阻塞状态，并清除打断标记；
  • 如果被打断的线程处于活跃状态，则会将线程的中断标识设置为true，被设置中断标识的线程将继续运行，不受影响；因此interrupt并不能真正的中断线程，需要设置为中断标识的线程自己进行处理，才能中断线程。
  • park的线程被打断，也会设置打断标记。
2、public static boolean interrupted()：Thread类的静态方法，判断线程是否被中断，并清除当前中断标识位，这个方法干了两件事：
  • 返回当前线程的中断状态。
  • 将当前线程的中断状态设置为false。
3、public boolean isInterrupted()：获取线程中断标识位的当前值，用于判断当前线程是否被中断，默认是false。

3、中断线程的几种方法

1、通过一个volatile变量实现
2、通过AtomicBoolean原子类实现
3、通过Thread类自带的中断方法实现
/**
 * @Date: 2022/7/18
 * 通过volatile中断停止线程
 */
public class Inter1 {
    static volatile boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (flag) {
                    System.out.println(Thread.currentThread().getName() + "停止运行，flag为：" + flag);
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在运行，flag为：" + flag);
            }
        }, "t1").start();

        Thread.sleep(1000);

        new Thread(() -> {
            flag = true;
            System.out.println(Thread.currentThread().getName() + "将flag修改为：" + true);
        }, "t2").start();
    }
}
/**
 * 运行结果如下：
 * t1正在运行，flag为：false
 * t1正在运行，flag为：false
 * t1正在运行，flag为：false
 * t1正在运行，flag为：false
 * t2将flag修改为：true
 * t1停止运行，flag为：true
 */

/**
 * @Date: 2022/7/18
 * 通过AtomicBoolean中断停止线程
 */
public class Inter2 {
    static AtomicBoolean flag = new AtomicBoolean(false);

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (flag.get()) {
                    System.out.println(Thread.currentThread().getName() + "停止运行，flag为：" + flag);
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在运行，flag为：" + flag);
            }
        }, "t1").start();

        Thread.sleep(1000);

        new Thread(() -> {
            flag.compareAndSet(false, true);
            System.out.println(Thread.currentThread().getName() + "将flag修改为：" + true);
        }, "t2").start();
    }
}
/**
 * 运行结果如下：
 * t1正在运行，flag为：false
 * t1正在运行，flag为：false
 * t1正在运行，flag为：false
 * t1正在运行，flag为：false
 * t2将flag修改为：true
 * t1停止运行，flag为：true
 */

/**
 * @Date: 2022/7/18
 * 通过Thread中断API停止线程
 */
public class Inter3 {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "停止运行，中断标识位为：" + Thread.currentThread().isInterrupted());
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在运行，中断标识位为" + Thread.currentThread().isInterrupted());
            }
        }, "t1");
        t1.start();

        new Thread(() -> {
            //打断t1线程
            t1.interrupt();
            System.out.println(Thread.currentThread().getName() + "将t1线程的中断标识位设置为：" + true);
        }, "t2").start();
    }
}
/**
 * 运行结果如下：
 * t1正在运行，中断标识位为false
 * t1正在运行，中断标识位为false
 * t1正在运行，中断标识位为false
 * t1正在运行，中断标识位为false
 * t2将t1线程的中断标识位设置为：true
 * t1停止运行，中断标识位为：true
 */

4、interrupt与isInterrupted的源码

1、interrupt方法：

在这里插入图片描述

2、isInterrupted方法：

在这里插入图片描述

5、interrupt被清除中断标识的情况

1、如果被打断线程处于被阻塞状态（如：sleep、wait、join等状态），会导致被打断的线程抛出InterruptedException，退出被阻塞状态，并清除打断标记
/**
 * @Date: 2022/7/18
 * 线程处于sleep、wait、join等状态被打断，抛出InterruptedException，并清除中断标识
 */
public class Inter4 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                     System.out.println(Thread.currentThread().getName() + "出现异常后，中断标识位为：" + Thread.currentThread().isInterrupted());
                    /**
                     * 当出现InterruptedException异常的时候，中断标识被清除（false），导出程序无法停止，进入死循环
                     * Thread.currentThread().interrupt();再次将中断标识设置为true
                     */
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "停止运行，中断标识位为：" + Thread.currentThread().isInterrupted());
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "正在运行，中断标识位为" + Thread.currentThread().isInterrupted());
            }
        }, "t1");
        t1.start();

        Thread.sleep(1000);

        new Thread(() -> {
            //打断t1线程
            t1.interrupt();
            System.out.println(Thread.currentThread().getName() + "将t1线程的中断标识位设置为：" + true);
        }, "t2").start();
    }
}
/**
 * 运行结果如下：可以看到出现异常后，中断标识为false，如果不再打断一次，程序不会停止，会死循环
 * t1正在运行，中断标识位为false
 * t1正在运行，中断标识位为false
 * t1正在运行，中断标识位为false
 * t1正在运行，中断标识位为false
 * t2将t1线程的中断标识位设置为：true
 * t1出现异常后，中断标识位为：false
 * t1停止运行，中断标识位为：true
 * java.lang.InterruptedException: sleep interrupted
 * 	at java.lang.Thread.sleep(Native Method)
 * 	at com.itan.interrupt.Inter4.lambda$main$0(Inter4.java:14)
 * 	at java.lang.Thread.run(Thread.java:748)
 */

二、LockSupport

1、概述

1、LockSupport用来创建锁和其他同步类的基本线程阻塞原语。是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程任意位置阻塞，阻塞之后有对应的唤醒方法，底层调用Unsafe中的native代码。

在这里插入图片描述

2、LockSupport类使用了一种名为permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit，最多只有一个，重复unpark不会累加凭证），它只有两个值1和0，默认是0。
3、当调用LockSupport.park时，表示当前线程将会等待，直至获得许可，当调用LockSupport.unpark时，必须把等待获得许可的线程作为参数进行传递，好让此线程继续运行。

2、让线程等待和唤醒的方法

1、使用Object中的wait方法让线程等待，使用notify方法唤醒线程。
2、使用JUC包中Condition的await方法让线程等待，使用signal方法唤醒线程。
3、LockSupport类可以阻塞当前线程以及唤醒指定的被阻塞的线程。

3、wait和notify方法实现线程等待和唤醒

1、调用wait方法使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用notify或者notifyAll方法来唤醒挂起的线程。
2、只能在同步方法或者同步块中使用，否则在运行时抛出IllegalMonitorStateExeception异常。

在这里插入图片描述

3、使用wait方法挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步块中，那么就无法执行notify方法或notifyAll方法来唤醒挂起的线程，造成死锁。
4、wait和notify必须成对出现使用，先wait后notify才有效。
/**
 * @Date: 2022/7/20
 * 正确使用wait与notify实现线程等待与唤醒
 */
@Slf4j
public class LockSupportTest1 {
    public static void main(String[] args) {
        Object objectLock = new Object(); //同一把锁，类似资源类
        new Thread(() -> {
            log.info(Thread.currentThread().getName() + "开始执行");
            synchronized (objectLock) {
                try {
                    //等待
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.info(Thread.currentThread().getName() + "线程被唤醒了");
        }, "t1").start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            synchronized (objectLock) {
                //唤醒
                objectLock.notify();
            }
        }, "t2").start();
    }
}
/**
 * 运行结果如下：t1线程在运行2后被t2线程唤醒继续执行
 * 23:49:21.669 [t1] INFO com.itan.locksupport.LockSupportTest1 - t1开始执行
 * 23:49:23.667 [t1] INFO com.itan.locksupport.LockSupportTest1 - t1线程被唤醒了
 */

4、Condition接口的await和signal方法

1、Condition是一个多线程协调通信的工具类，可以让某些线程一起等待某个条件（condition），只有满足条件时，线程才会被唤醒。
2、Condition对象是由Lock对象（调用Lock对象的newCondition方法）创建的，也就是说Condition是依赖Lock对象的。
3、当调用await方法后，当前线程会释放锁并在此等待，而其他线程调用Condition对象signal方法，通知当前线程后，当前线程才从await方法返回，并且在返回前已经获取了锁。
4、在调用方法前必须获取到锁，否则会抛出IllegalMonitorStateExeception异常。
/**
 * @Date: 2022/7/20
 * 正确使用Condition实现线程等待与唤醒
 */
@Slf4j
public class LockSupportTest2 {
    public static void main(String[] args) {
        //创建Lock对象
        Lock lock = new ReentrantLock();
        //通过lock.newCondition创建Condition对象
        Condition condition = lock.newCondition();
        new Thread(() -> {
            //加锁
            lock.lock();
            try {
                log.info(Thread.currentThread().getName() + "开始执行");
                //等待
                condition.await();
                log.info(Thread.currentThread().getName() + "线程被唤醒了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                //释放锁
                lock.unlock();
            }
        }, "t1").start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            //加锁
            lock.lock();
            try {
                //唤醒
                condition.signal();
                log.info(Thread.currentThread().getName() + "线程通知唤醒");
            } finally {
                //释放锁
                lock.unlock();
            }
        }, "t2").start();
    }
}
/**
 * 运行结果如下：t1线程在运行2后被t2线程唤醒继续执行
 * 00:15:13.357 [t1] INFO com.itan.locksupport.LockSupportTest2 - t1开始执行
 * 00:15:15.364 [t2] INFO com.itan.locksupport.LockSupportTest2 - t2线程通知唤醒
 * 00:15:15.364 [t1] INFO com.itan.locksupport.LockSupportTest2 - t1线程被唤醒了
 */

5、LockSupport类中的park和unpark方法

1、阻塞方法：park()阻塞当前线程或park(Object blocker)阻塞传入的具体线程
  • 由于permit默认是0，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park方法会被唤醒，然后会将permit再次设置为零并返回。
2、唤醒方法：unpark(Thread thread)唤醒处于阻塞状态的指定线程
  • 调用unpark(thread)方法后，就会将thread线程的许可permit设置成1（注意多次调用unpark方法，不会累加，permit值还是1）会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回。
3、相对于前面两种方法，LockSupport无需加锁就能实现等待和唤醒。
4、LockSupport不仅支持先等待后唤醒，而且也支持先唤醒后等待，如果是先唤醒，就不会再阻塞线程的执行了。
/**
 * @Date: 2022/7/20
 * 正确使用LockSupport实现线程等待与唤醒
 */
@Slf4j
public class LockSupportTest3 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.info(Thread.currentThread().getName() + "开始执行");
            //等待
            LockSupport.park();
            log.info(Thread.currentThread().getName() + "线程被唤醒了");
        }, "t1");
        t1.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            log.info(Thread.currentThread().getName() + "线程通知唤醒");
            //唤醒
            LockSupport.unpark(t1);
        }, "t2").start();
    }
}
/**
 * 运行结果如下：t1线程在运行2后被t2线程唤醒继续执行
 * 23:52:53.771 [t1] INFO com.itan.locksupport.LockSupportTest3 - t1开始执行
 * 23:52:55.767 [t2] INFO com.itan.locksupport.LockSupportTest3 - t2线程通知唤醒
 * 23:52:55.768 [t1] INFO com.itan.locksupport.LockSupportTest3 - t1线程被唤醒了
 */

6、总结

1、使用Object类中wait、notify方法让线程等待和唤醒，以及Condition接口中await、signal方法让线程等待和唤醒的前提：
  • 线程首先要获得并持有锁，必须在synchronized或lock中。
  • 必须要先等待后唤醒，线程才能被唤醒。
2、LockSupport无需加锁就能实现等待和唤醒，不仅支持先等待后唤醒，而且也支持先唤醒后等待，如果是先唤醒，就不会再阻塞线程的执行了。
3、对LockSupport唤醒两次后阻塞两次，最终还会阻塞线程的解释：
  • 因为permit的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证。
  • 连续调用两次park却需要消费两个凭证，因此凭证不够，阻塞线程。
【JUC】Java并发编程从挖坑到入土全解（4-一文讲通LockSupport与线程中断-＞长图预警）
aqin1012的博客
10-10 553
首先，一个线程不应该由其他线程强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运（所以，Thread的stop()、suspend()、resume()都已经废弃了）其次，在Java中没有办法立即停止一条线程，然而停止线程又显得那么重要（比如需要取消一个耗时/错误操作）。因此，Java提供了一种用于停止线程的协商机制——中断，也即中断标识协商机制。中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完成完全要求程序员自己实现。
线程中断 interrupt 和 LockSupport
烟雨星空的博客
03-01 962
本文章将要介绍的内容有以下几点，读者朋友也可先自行思考一下相关问题： 线程中断 interrupt 方法怎么理解，意思就是线程中断了吗？那当前线程还能继续执行吗？ 判断线程是否中断的方法有几个，它们之间有什么区别？ LockSupport的 park/unpark 和 wait/notify 有什么区别？ sleep 方法是怎么响应中断的？ park 方法又是怎么响应中断的？ 线程中断相关方法...
LockSupport与线程中断
Json_book的博客
10-31 242
LockSupport与线程中断
第五章：LockSupport与线程中断
YZG ' BLOG
11-25 398
首先一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，都已经被废弃了。其次在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java 提供了一种用于停止线程的协商机制——中断。中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。若要中断一个线程，你需要手动调用该线程的 interrupt 方法，该方法也仅仅是将线程对象的中断标识设成true；
java线程阻塞中断与LockSupport使用介绍
09-05
如果线程中断状态已经设置，`park()` 会立即返回，即使没有调用过`unpark()`。 **7. Thread.interrupt()处理是否有回调函数？** Java API中并没有提供线程中断的直接回调函数。但是，可以通过在`run()` 方法中检查...
Java线程中断与LockSupport深度解析
"java线程阻塞中断与LockSupport使用介绍" 在Java多线程编程中，线程的阻塞和中断以及同步工具的正确使用至关重要。`Thread.interrupt()` 和 `LockSupport` 是两个关键的概念，它们分别代表了对线程中断机制的不同...
详解Java多线程编程中LockSupport类的线程阻塞用法
09-02
在Java多线程编程中，LockSupport类是一个重要的工具，它提供了一种低级别的线程阻塞和唤醒机制。LockSupport并不像synchronized或java.util.concurrent.locks包中的Lock接口那样提供锁的完整功能，但它提供了两个...
4、线程中断与LockSupport
PingFanXianSheng的博客
08-04 219
一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己来决定自己是否停止。在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的协商机制——中断，即中断标识协商机制。也仅仅是将线程对象中的中断标识设成true。生活例子:顾客在餐厅中吸烟，服务员只能提醒他别吸烟了；而不是强制停止顾客吸烟。具体停止吸烟行为还是需要顾客自己做出操作（顾客可以停止吸烟，也可以不停止吸烟）。——体现了协商机制。...
Java并发包源码学习之AQS框架（三）LockSupport和interrupt
henry的专栏
03-14 647
其实除了LockSupport，Java之初就有Object对象的wait和notify方法可以实现线程的阻塞和唤醒。那么它们的区别 是什么呢？ 主要的区别应该说是它们面向的对象不同。阻塞和唤醒是对于线程来说的，LockSupport的park/unpark更符合这个语义，以“线程”作为方法的参数， 语义更清晰，使用起来也更方便。而wait/notify的实现使得“线程”的阻塞/唤醒对线
JUC-LockSupport与线程中断
一生烟雨的博客
11-07 596
LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，当然阻塞之后肯定得有唤醒的方法.
并发编程04：LockSupport与线程中断
m0_66689823的博客
05-07 423
并发编程03：LockSupport与线程中断
第五章：线程中断机制
weixin_48276298的博客
06-19 431
什么是中断？ 首先一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，Thread.stop, Thread.suspend,Thread.resume 都已经被废弃了。 其次在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的机制——中断。 中断只是一种协作机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。若要中断一个线程，你需要手动调用该线程的interrupt方法，该方法也仅仅是将线
java并发编程---Thread.interrupted方法对LockSupport.park()的影响
e891377的专栏
03-07 1114
文章目录interrupted方法对LockSupport.park()的影响先看，方法三再看方法五方法六总结 interrupted方法对LockSupport.park()的影响 先看，方法三 private static void test3() throws InterruptedException { Thread t1 = new Thread(() ->...
Java并发编程基础
void
07-20 1803
Java多线程基础与生产者/消费者的实现
线程等待唤醒机制（LockSupport） 与 线程中断（interrupt）
lesliewongjie
02-01 625
线程等待唤醒机制（LockSupport） 与 线程中断（interrupt）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值