线程中断innterrupt(未完结)

最新推荐文章于 2021-05-06 20:51:59 发布
最新推荐文章于 2021-05-06 20:51:59 发布
阅读量386 收藏
点赞数
分类专栏： Think in Java 文章标签： innterrupt
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lovincc/article/details/80841359
版权

signalAll()和synchronized

当我试着使用lock来控制锁的，发现以下有趣的现象

public class WaxOMatic {

    public static void main(String[] args) throws InterruptedException {
        Car car = new Car();
        ExecutorService s = Executors.newFixedThreadPool(2);
        s.execute(new Thread(new WaxOn(car)));
        s.execute(new Thread(new WaxOff(car)));
        TimeUnit.SECONDS.sleep(5);
       // s.shutdownNow();


    }

}

class Car {

    private boolean waxOx = false;
    Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();


    public synchronized void waxed() {
       /* lock.lock();
        try {*/

            waxOx = true;
            notifyAll();
//            condition.signalAll();
       /* } finally {
            lock.unlock();

        }*/

    }


    public void buffed() {
        lock.lock();
        try {
            waxOx = false;
//            notifyAll();
            condition.signalAll();
        } finally {
            lock.unlock();

        }

    }


    public /** synchronized */
    void waitForWaxing() throws InterruptedException {
        lock.lock();
        try {
            System.out.println();
            while (waxOx == false) {
                System.out.println("waitfor ..... ");
//                wait();
                condition.await();
            }
        } finally {
            lock.unlock();

        }
    }


    public /** synchronized */
    void waitForBuffing() throws InterruptedException {
        lock.lock();
        try {
            while (waxOx == true) {
//                wait();
                condition.await();
            }
        } finally {
            lock.unlock();

        }
    }
}


class WaxOn implements Runnable {

    private Car car;

    public WaxOn(Car car) {
        this.car = car;
    }


    @Override
    public void run() {
        while (!Thread.interrupted()) {
            System.out.println("start wax  on .....");
//            System.out.println("name = " + Thread.currentThread().getName());
            try {
                TimeUnit.MILLISECONDS.sleep(200);
                car.waxed();
                System.out.println(" --- wax ----");
                car.waitForBuffing();

            } catch (InterruptedException e) {
                e.printStackTrace();
                Thread.currentThread().interrupt();
            }

            System.out.println("end waxing ......");

        }

    }
}


class WaxOff implements Runnable {

    private Car car;

    public WaxOff(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        System.out.println("start buffed ...");
        try {
            while (!Thread.interrupted()) {
                car.waitForWaxing();
                System.out.println(" ---- buf ---");
                TimeUnit.MILLISECONDS.sleep(200);
                car.buffed();

            }

        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        } finally {

        }
        System.out.println("end buffed /...");

    }
}

可以看到waxed()方法，使用了synchronize获取锁，其他则使用了lock,
在执行过程中，发现，WaxOn给Car加工后按理说应该唤醒WaxOff了，因为在加工完成后，调用了notifyAll(),并且改变控制信号错失的值为true,随后自己进行await(),但是却没有唤醒WaxOff()方法.

这里写图片描述

第一行表示WaxOf已经给Car开始加工了
第二行语句代表WaxOff已经启动，因为因为需要等待WaxOn加工后所以才能操作，所以进入await()，等待被WaxOn加工完成，唤醒执行
第三行，这样WaxOn中加工已经完成了，一直在等待WaxOff执行
但是WaxOff却没有被唤醒执行后续的加工，整个线程被锁了

我们用jstack看看状态
这里写图片描述

可以看到，WaxOff还在等待WaxOn的加工完成的唤醒,由于WaxOn加工后进行了notifyAll，但是却并没有唤醒，使WaxOff一直陷入waiting,然后WaxOn加工后自己也进入了waiting,等待被WaxOff处理。所以这里我们看到了两个线程都进入了waiting,都需要被对方等待唤醒，但却永远不会有操作，陷入了死锁.

原因

因为waxed使用synchronized获取锁，而其他则使用了lock,由于synchronized和lock获取锁的方式不同，condition 来自于某个lock.,通过lock.lock()获取锁，object 通过.synconize() 获取锁，这样就导致他们获取的不是同一个锁，释放了锁，但是却不是对方所需要的锁,故而对着需要该锁的当前线程的notifyAll并不是对方的notifyAll。

中断注意事项

public class WaxOMatic {

    public static void main(String[] args) throws InterruptedException {
        Car car = new Car();
        ExecutorService s = Executors.newFixedThreadPool(2);
        s.execute(new Thread(new WaxOn(car)));
        s.execute(new Thread(new WaxOff(car)));
        TimeUnit.SECONDS.sleep(5);
        s.shutdownNow();


    }

}

class Car{

    private boolean waxOx = false;


    public synchronized void waxed(){
        waxOx = true;
        notifyAll();

    }


    public synchronized void buffed(){
        waxOx = false;
        notifyAll();

    }


    public synchronized void waitForWaxing() throws InterruptedException {
       while (waxOx == false) {
           wait();
       }
    }


    public synchronized void waitForBuffing() throws InterruptedException {
        while (waxOx == true){
            wait();

        }
    }
}


class WaxOn implements Runnable{

    private Car car;

    public WaxOn(Car car) {
        this.car = car;
    }



    @Override
    public void run() {
        while (!Thread.interrupted()){
            System.out.println("start wax  on .....");
            System.out.println("name = " + Thread.currentThread().getName());
            try {
                TimeUnit.SECONDS.sleep(1);
                car.waxed();
                System.out.println(" --- wax ----");
                car.waitForBuffing();

            } catch (InterruptedException e) {
                e.printStackTrace();
               // Thread.currentThread().interrupt();
            }

            System.out.println("end waxing ......");

        }

    }
}


class WaxOff implements Runnable{

    private Car car;

    public WaxOff(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        System.out.println("start buffed ...");
        try {
            while (!Thread.interrupted()){
                car.waitForWaxing();
                System.out.println(" ---- buf ---");
                TimeUnit.MILLISECONDS.sleep(200);
                car.buffed();

            }

        } catch (InterruptedException e) {
            e.printStackTrace();
           // Thread.currentThread().interrupt();
        } finally {

        }
        System.out.println("end buffed /...");

    }
}

以上代码是thinking in java中的demo，发现一个奇怪的问题,线程在中断后有一个奇怪现象，在执行中断操作后，线程又重新跑了一次。
这里写图片描述

经过思考原因，反复论证，中断操作对于 I/O，尝试获取锁无法中断，对于sleep，wait等的阻塞状态中断会发生InterruptedException异常，在这里我们需要处理中断,Thread.currentThread().interrupt();//重新设置中断标示位,让线程从阻塞中退出。
这里写图片描述

如图，加上中断处理

这里写图片描述

设置中断位后，都已经结束了.线程也没有挂起，中断起到作用了。

总结

对于处于wait(),sleep，join等操作的线程，如果被调用interrupt()后，会立即重置中断位为false和抛出InterruptedException，因为线程为了处理异常已经重新处于就绪状态。,再一次重新启动的原因就是这个，线程在触发中断的异常后，便会再让这个线程重新处于就绪，重新执行。可以再捕获InterruptedException后return,break或者再一次Thread.interrupted()再次设置中断位也可以起到中断线程的作用

被天上的包子砸晕
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Thread类中interrupt（）、interrupted（）和isInterrupted（）方法详解
qq_39682377的博客
08-06 11万+
首先看看官方说明： interrupt（）方法 其作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。   interrupted（）方法 作用是测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，第二次再调用时中断状态已经被清除，将返回一个false。   ...
线程的interrupt()方法解析
qq_24516549的博客
03-27 1230
interrupt()方法是thread里的一个方法,具体先看源码注释 1.方法描述 /** * Interrupts this thread. * * <p> Unless the current thread is interrupting itself, which is * always permitted, the {@link...
对线程interrupt的初浅理解
王文萱的博客
11-26 307
在java中，使用interrrupt可以用来请求中止线程。对一个线程调用interrrupt方法时，该线程的中断状态位被置位，每个线程不断访问自己的这个标志，以判断线程是否被中断（只是要求java开发者去添加的判断，并不在内部实现）。可以调用Thread的方法isInterrupted判断是否线程中断，代码如下： //5s后interrup请求打印一个异常 public class M...
linux的异步IO——使用signal实现中断
cryil_0301的博客
02-28 925
signal函数的使用以及signal函数异步处理函数之间的传参问题。
linux下 如何用信号signal 终止或者暂停子线程,操作系统常见面试问题
weixin_32308019的博客
05-06 576
一、操作系统基础1、请你说一说并发(concurrency)和并行(parallelism)并发(concurrency)：指宏观上看起来两个程序在同时运行，比如说在单核cpu上的多任务。但是从微观上看两个程序的指令是交织着运行的，你的指令之间穿插着我的指令，我的指令之间穿插着你的，在单个周期内只运行了一个指令。这种并发并不能提高计算机的性能，只能提高效率。并行(parallelism)：指严格物...
浅析java线程中断的办法
10-18
合理使用线程中断机制，可以避免一些线程资源未释放导致的问题。在实现时，需要根据线程执行的具体情况，合理设计中断处理逻辑。在Java并发编程中，掌握线程中断的知识点对于编写高效且稳定的多线程程序至关重要。
详解Java线程中断知识点
08-26
Java线程中断是多线程编程中一个关键的概念，它允许一个线程在运行时被其他线程“通知”停止其当前活动。线程中断不是立即终止线程，而是发送一个中断信号，由目标线程自己决定如何响应这个信号。在Java中，线程中断...
Java线程中断的本质深入理解
09-05
当调用`interrupt()`方法时，目标线程的中断标志被设置为true，但实际的中断行为取决于线程自身。线程必须在运行过程中定期检查中断状态，如通过`Thread.interrupted()`或`isInterrupted()`，并在适当的时候采取行动...
java线程阻塞中断与LockSupport使用介绍
09-05
Java线程阻塞中断是Java并发编程中的一个重要概念，它涉及到线程的生命周期管理以及协作。`Thread.interrupt()` 方法是用于向线程发送中断请求，而`LockSupport` 是Java 5引入的一个低级别的线程同步工具，提供了比`...
《Java编程思想》学习笔记19——并发编程（二）
Tony Chen的专栏
12-06 3723
1.java中的原子操作类： 原子操作是指程序编译后对应于一条CPU操作指令，即原子操作是最小的不可再分指令集，编程中的原子操作是线程安全的，不需要使用进行线程同步和加锁机制来确保原子操作的线程同步。 JDK5中引入了java.util.concurrent.atomic原子操作类包，提供了常用的原子类型操作数据类型，如：AtomicInteger,AtomicLong, AtomicRefe
关于学习java多线程的一些感想
zhoulupeng2012的博客
11-29 613
一、基本概念 1.进程与线程 进程作为程序的一次执行，它是有独立的内存空间的；而线程可以理解为一个进程中的多个独立运行的子任务，是CPU调度的最小单元。一个进程可以包含多个线程。2.实现线程的两种方式 （1）继承Thread类 （2）实现Runnable接口（推荐， 因为可以支持多继承） 注意：线程是一个子任务，CPU以随机的时间来调用他的run方法，若同时启动多个线程，调用start（）
[原创][Java]由一个Java编程思想书中线程间协作的例子想到的
枣子的IT专栏
10-11 759
Java编程思想一书中第21章并发中关于线程
多线程、并发（很乱）
Jesse_cool的博客
05-24 1237
先复习下 我们先了解一下Thread的几个重要方法。 a、start()方法，调用该方法开始执行该线程； b、stop()方法，调用该方法强制结束该线程执行； c、join方法，调用该方法等待该线程结束，用于主线程等待子线程执行结束。 d、sleep()方法，调用该方法该线程进入等待。 e、run()方法，调用该方法直接执行线程的run()方法，但是线程调用start()方法...
Attach函数的讲解
热门推荐
Barry的博客
02-02 1万+
Attach函数在MFC中是比较常见的，在不少类中都有这个成员函数例如CWnd类，CDC类，CBitmap类等。通用一点来说， 它的作用是：关联windows的资源句柄和c++对象，窗口是资源，绘图设备也是资源，所以它们的类中会有这个函数关联windows的资源句柄和c++对象。这么说好像很抽象，下面以CWnd类中的Attach详细讲解，当你看完再回过头来看这段话时，就会明白了。 CW
JAVA并发总结－基础篇
技海拾贝
05-31 1932
文章的起源来自于并发编程网上一篇关于并发的面试题的帖子，自己回答了一份。
Java多线程互斥Demo
weixin_41400063的博客
05-27 750
今天看java编程思想的并发篇，看到了一个熟悉而又总是出错的并发互斥问题。WaxOMatic.java有两个过程：一个是将蜡涂到Car上，一个是抛光他。在抛光任务在涂蜡任务完成之前，是不能执行其工作的，而涂蜡任务在涂另一层蜡之前，必须等待抛光任务完成。我们根据题目建立一个数学模型：        根据我们的数学模型，我们建立了两个类WaxOn和WaxOff分别表示上蜡和抛光任务，在上蜡动任务中，分...
Java并发之线程之间协作
惜暮
12-28 1841
线程之间的协作1.wait()和notify()、notifyAll()方法(这些方法均属于基类Object)wait()函数的调用使当前线程A被阻塞以等待某个外部条件的发生(这个外部条件超出了当前方法的控制能力)，通常这个条件由另外一个任务B来改变，当另外的这个任务B调用notify()或则notifyAll()时，线程A将被唤醒。所以wait()提供了一种不同人物之间活动的一种同步方式。 调
Thinking in java 涂蜡抛光WaxOnWaxOff程序学习
u013905744的专栏
06-28 456
Thinking in java 涂蜡抛光WaxOnWaxOff程序学习
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
最新发布
08-14
【独家首发】基于蜣螂优化算法DBO-GMDH的风电数据回归预测研究Matlab实现.rar
python线程中断再启动
06-19
在Python中，线程的中断和重启可以通过`threading`模块的`Event`对象以及`Thread`类的方法来实现。`Event`类提供了同步机制，你可以创建一个事件对象，并设置为`set()`来表示线程可以中断，然后在需要的地方调用`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值