如何停止一个线程?

最新推荐文章于 2023-05-26 11:55:18 发布
最新推荐文章于 2023-05-26 11:55:18 发布
阅读量3.5k 收藏 17
点赞数 1
文章标签： java 并发编程
原文链接：https://blog.csdn.net/chenliguan/article/details/110325209
版权

1 如何停止一个线程?

  1. 不能简单的停止(Stop())一个线程。因为停止stop()会直接把线程停止，这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑，任务戛然而止，会导致出现数据完整性等问题；
  2. 虽然线程不能在中间被停止/干掉，但是任务是可以停止的；想让线程结束的目的是让任务结束，而不是强制线程结束。有两种方式结束任务，分别是：Interrupt和boolean标志位；
  3. 使用线程中断机制-interrupt停止线程，分2种情况。如果原生支持interrupt：sleep、wait等可以让线程进入阻塞的方法使线程休眠了，而处于休眠中的线程被中断，那么线程是可以感受到中断信号的，并且会抛出一个InterruptedException异常，同时清除中断信号，将中断标记位设置成false。非原生如果支持interrupt，每执行一次任务，调用interrupted()或isInterrupted()询问一遍系统是否已经中断了，如果中断了系统会告诉我们已经中断了，然后可以实现中断的逻辑。
  4. 其中，interrupt底层的原理是在Native层加锁。然后判断interrupted_值是否等于true，是的直接返回，表示已经是中断状态了；否则，把interrupted_置为true，发出中断通知。实现原理和boolean标志位的实现逻辑很像。
  5. interrupted()与isInterrupted()之间的区别是：在Java层，interrupted()是静态方法，获取当前线程的中断状态后并清空，重复调用后续返回false；isInterrupted()是非静态方法，获取线程对象对应线程的中断状态，不清空，可重复调用，中断清空前一直返回true。在Native层，interrupted()比isInterrupted()多调用了SetInterruptedLocked(false)方法，清空当前中断状态，其他的都一致。
  6. 使用volatile boolean标志位停止线程：线程中设置一个boolean标志位值为false，线程里不断读取这个boolean值，其他地方可以修改这个boolean值；为了保证内存可见性，给boolean标志位添加volatile保证可见性；当某一个线程修改boolean标志位为true，线程中能立刻看到。
  7. 如何选择interrupt和boolean标志位去停止线程？interrupt()和boolean标志位的原理是一致的。除非是用到了系统方法时(如:sleep) 或者 使用阻塞队列在线程中执行put()时发生阻塞，使用interrupt()；否则，建议使用boolean标志位，性能更优，毕竟interrupt使用JNI有一定的开销。

1.1 这道题想考察什么?

答：（1）考察要点
●是否对线程的用法有了解；是否对线程的stop方法有了解(初级)
●是否对线程stop过程中存在的问题有认识；是否熟悉interrupt中断的用法(中级)
●是否能解释清楚使用boolean标志位的好处；是否知道interrupt底层的细节；通过该题目能够转移话题到线程安全，并阐述无误(高级)

（2）题目剖析
●如何停止一个线程?
●官方停止线程的方法被废弃，所以不能直接简单的停止线程？如何设计可以随时被中断而取消的任务线程？
 

2 为什么不能简单的停止(Stop())一个线程?

答：因为停止stop()会直接把线程停止，这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑，任务戛然而止，会导致出现数据完整性等问题。
如下图：Thread1被停止stop()后，立即释放内存锁；Thread3获得内存锁，马上加锁。Thread1根本没有清理内存的机会，原来写数据写到一半，现在没有机会继续写了，因为线程被杀掉了；接着，Thread3获得了时间片，开始读数据时发现内存状态异常，读到一个莫名其妙的数据，因为Thread1还没清理干净就停止线程了，留下一个烂摊子给Thread3，Thread3也会面临crash。所以，这样的停止操作是非常危险的。也正是这个原因，无论什么语言都把停止的api废弃了。

2.1 为什么暂停和继续(suspend()和resume())也被废弃了？

答：因为对于暂停suspend()和继续resume()，它们的问题在于如果线程调用suspend()，它并不会释放锁，就开始进入休眠，但此时有可能仍持有锁，这样就容易导致死锁问题，因为这把锁在线程被resume()之前，是不会被释放的。
如下图：Thread1调用暂停suspend()后进入休眠，但是仍持有内存锁；Thread3拿不到锁，会陷入阻塞，等待Thread1持有的内存锁释放。如果Thread1一直持有锁，Thread3一直在等待，就会出现死锁的情况。所以线程suspend()和resume()方法也被废弃了。

2.2 什么是协作的任务执行模式？

答：虽然线程不能在中间被停止/干掉，但是任务是可以停止的；想让线程结束的目的是让任务结束，而不是强制线程结束。

线程在设计过程中，主要是任务执行模式的设计，线程和任务是强绑定的，任务执行完了，线程也就结束了。虽然线程不能在中间被停止/干掉，但是任务是可以停止的，所以任务的执行模式是协作的任务执行模式。我们想让线程结束的目的是让任务结束，而不是强制线程结束。线程被停止和线程自己运行完，对开发者来说是没区别，但是对程序是有明显区别的。线程自己正常运行完，可以正常清理它创造的烂摊子；如果它被干掉了，它的烂摊子就不能被清理了，只能留给其他线程。所以，我们在设计上，应该是在任务上添加停止/结束的逻辑，而不是在线程上添加。我们有两种方式结束任务，分别是：Interrupt和boolean标志位。

3 如何使用线程中断机制-interrupt停止线程？

答：（1）如果原生支持interrupt：sleep、wait等可以让线程进入阻塞的方法使线程休眠了，而处于休眠中的线程被中断，那么线程是可以感受到中断信号的，并且会抛出一个InterruptedException异常，同时清除中断信号，将中断标记位设置成false。

// interrupt的原生支持 -> Sleep()
public static void rawInterrupt() throws InterruptedException {
        // 创建目标线程
        Thread interruptRawThread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " 线程正在执行...");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println(Thread.currentThread().getName() + " 线程接收到中断信息，中断线程...");
            }
        }, "rawInterrupt");
        // 启动目标线程
        interruptRawThread.start();

        // 中断通知
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("rawInterrupt 设置线程中断....");
        interruptRawThread.interrupt();

//        rawInterrupt 线程正在执行...
//        rawInterrupt 设置线程中断....
//        rawInterrupt 线程接收到中断信息，中断线程...
    }

（2）非原生不支持interrupt。

// 不支持 interrupt()
public static void unInterrupt() {
        // 创建目标线程
        Thread unInterruptThread = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                if (i % 10000 == 0) {
                    System.out.println(Thread.currentThread().getName() + " 线程正在执行... " + i);
                }
            }
        }, "unInterrupt");
        // 启动目标线程
        unInterruptThread.start();

        // 中断通知
        System.out.println("unInterrupt 设置线程中断....");
        unInterruptThread.interrupt();

//        unInterrupt 设置线程中断....
//        unInterrupt 线程正在执行... 0
//        unInterrupt 线程正在执行... 10000
//        unInterrupt 线程正在执行... 20000
//        unInterrupt 线程正在执行... 30000
//        unInterrupt 线程正在执行... 40000
//        unInterrupt 线程正在执行... 50000
//        unInterrupt 线程正在执行... 60000
//        unInterrupt 线程正在执行... 70000
//        unInterrupt 线程正在执行... 80000
//        unInterrupt 线程正在执行... 90000
    }

 （3）非原生如果支持interrupt，每执行一次任务，调用interrupted()或isInterrupted()询问一遍系统是否已经中断了，如果中断了系统会告诉我们已经中断了，然后可以实现中断的逻辑。

// 支持 interrupted()
public static void supportInterrupted() {
        // 创建目标线程
        Thread supInterruptThread = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                System.out.println(Thread.currentThread().getName() + " 线程正在执行... " + i);
                // 判断当前线程是否中断，
                if (interrupted()) {
                    System.out.println(Thread.currentThread().getName() + " 线程接收到中断信息，中断线程...");
                    break;
                }
            }
        }, "supportInterrupted");
        // 启动目标线程
        supInterruptThread.start();

        // 中断通知
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("supportInterrupted 设置线程中断....");
        supInterruptThread.interrupt();

//        supportInterrupted 设置线程中断....
//        supportInterrupted 线程正在执行... 0
//        supportInterrupted 线程接收到中断信息，中断线程...
    }

// 支持 IsInterrupted()
public static void supportIsInterrupted() {
        // 创建目标线程
        Thread supInterruptThread = new Thread(() -> {
            for (int i = 0; i < 100000; i++) {
                System.out.println(Thread.currentThread().getName() + " 线程正在执行... " + i + " isInterrupted()：" + Thread.currentThread().isInterrupted());
                // 判断该线程是否中断，
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + " 线程接收到中断信息，中断线程...");
                    break;
                }
            }
        }, "supportIsInterrupted");
        // 启动目标线程
        supInterruptThread.start();

        // 中断通知
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("supportIsInterrupted 设置线程中断....");
        supInterruptThread.interrupt();

//        supportIsInterrupted 线程正在执行... 0 isInterrupted()：false
//        supportIsInterrupted 线程正在执行... 1 isInterrupted()：false
//        supportIsInterrupted 线程正在执行... 2 isInterrupted()：false
//        supportIsInterrupted 设置线程中断....
//        supportIsInterrupted 线程正在执行... 3 isInterrupted()：true
//        supportIsInterrupted 线程接收到中断信息，中断线程...
    }

3.1 是否知道interrupt底层的原理？

答：在Native层加锁。然后判断interrupted_值是否等于true，是的直接返回，表示已经是中断状态了；否则，把interrupted_置为true，发出中断通知。实现原理和boolean标志位的实现逻辑很像。

（1）Java层用法

supInterruptThread.interrupt();

（2）Thread.java层的实现

// Thread.java
public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();
    synchronized (blockerLock) {
        Interruptible b = blocker;
        if (b != null) {
            interrupt0();  // Just to set the interrupt flag
            b.interrupt(this);
            return;
        }
    }
    interrupt0();
}

private native void interrupt0();  // native方法

（3）Native层实现：MutexLock mu(self,*wait_ mutex_)指先加了锁。然后判断interrupted_值是否等于true，是的直接返回，表示已经是中断状态了；否则，把interrupted_置为true，发出中断通知。实现原理和boolean标志位的实现逻辑很像。

补充最新源码：/thread.cc# Interrupt() 

3.2 interrupted()与isInterrupted()有什么区别？

答：在Java层，interrupted()是静态方法，获取当前线程的中断状态后并清空，重复调用后续返回false；isInterrupted()是非静态方法，获取线程对象对应线程的中断状态，不清空，可重复调用，中断清空前一直返回true。在Native层，interrupted()比isInterrupted()多调用了SetInterruptedLocked(false)方法，清空当前中断状态，其他的都一致。
 

（1）Java层的区别：

（2）Native层-Thread.cc的区别：

interrupted()是静态方法：先拿到JNI的环境JNIEnv，他里面有个成员叫self，self就是底层线程的对象，调用的是这个self对象的interrupted()方法；
isInterrupted()是非静态方法：对应一个Java线程的对象，先找到这个Java线程的对象对应的底层线程对象，再调用这个底层线程对象的isInterrupted()方法。

补充最新源码：/thread.cc# interrupted() + isInterrupted() 

补充最新源码：/thread.cc# storeSequentiallyConsistent() 

3.3 InterruptedException的两种最佳处理方式？

 答：在实际开发中肯定是团队协作的，不同的人负责编写不同的方法，然后相互调用来实现整个业务的逻辑。
（1）可以在方法中使用 try/catch 或在方法签名中声明 throws InterruptedException

void subTas() {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // 在这里不处理该异常是非常不好的
    }
}

void subTask2() throws InterruptedException {
    Thread.sleep(1000);
}

（2）再次中断：如果这时手动添加中断信号，中断信号依然可以被捕捉到。这样后续执行的方法依然可以检测到这里发生过中断，可以做出相应的处理，整个线程可以正常退出。

private void reInterrupt() {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        e.printStackTrace();
    }
}

4 如何用volatile boolean标志位通知线程停止？

答：（1）线程中设置一个boolean标志位值为false，线程里不断读取这个boolean值，其他地方可以修改这个boolean值；

（2）但是，boolean标志位没加锁，其他线程修改boolean标志位为true，线程中不一定能看到

 

 （3）为了保证内存可见性，给boolean标志位添加volatile保证可见性；当某一个线程修改boolean标志位为true，线程中能立刻看到

（4）案例

// 创建目标线程
static class BooleanThread extends Thread {
        volatile boolean isStopped = false;

        @Override
        public void run() {
            for (int i = 0; i < 100000; i++) {
                System.out.println("volatileBoolean 线程正在执行... " + i);
                // 判断该线程boolean标志位是否有效
                if (isStopped) {
                    System.out.println("volatileBoolean 线程接收到中断信息，中断线程...");
                    break;
                }
            }
        }
    }

// volatile boolean标志位
public static void volatileBoolean() {
        BooleanThread booleanThread = new BooleanThread();
        // 启动目标线程
        booleanThread.start();

        // 中断通知
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("volatileBoolean 设置线程中断....");
        booleanThread.isStopped = true;

//        volatileBoolean 设置线程中断....
//        volatileBoolean 线程正在执行... 0
//        volatileBoolean 线程接收到中断信息，中断线程...
    }

4.1 为什么用boolean标志位的停止方法不一定准确的？

答：使用阻塞队列在线程中执行queue.put()时发生阻塞，在它被叫醒之前是没有办法进入下一次循环判断canceled的值的，所以在这种情况下用volatile不能让任务停下来。

public static void volatileBooleanNot() {
        try {
            ArrayBlockingQueue storage = new ArrayBlockingQueue(8);
            Producer producer = new Producer(storage);
            Thread producerThread = new Thread(producer);
            producerThread.start();

            Thread.sleep(500);
            Consumer consumer = new Consumer(storage);
            while (consumer.needMoreNums()) {
                System.out.println("volatileBooleanNot " + consumer.storage.take() + "被消费了");
                Thread.sleep(100);
            }
            System.out.println("volatileBooleanNot 消费者不需要更多数据了。");
            // 一旦消费不需要更多数据了，我们应该让生产者也停下来，但是实际情况却停不下来
            producer.canceled = true;
            System.out.println("volatileBooleanNot " + producer.canceled);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 不能结束，不会打印：volatileBooleanNot 生产者结束运行
//        volatileBooleanNot 0是50的倍数,被放到仓库中了。
//        volatileBooleanNot 50是50的倍数,被放到仓库中了。
//        volatileBooleanNot 100是50的倍数,被放到仓库中了。
//        volatileBooleanNot 150是50的倍数,被放到仓库中了。
//        volatileBooleanNot 0被消费了
//        volatileBooleanNot 50被消费了
//        volatileBooleanNot 消费者不需要更多数据了。
//        volatileBooleanNot true
    }

    static class Producer implements Runnable {
        public volatile boolean canceled = false;
        public BlockingQueue storage;

        public Producer(BlockingQueue storage) {
            this.storage = storage;
        }

        @Override
        public void run() {
            int num = 0;
            try {
                while (num <= 100000 && !canceled) {
                    // 生产者在执行storage.put(num)时发生阻塞，在它被叫醒之前是没有办法进入下一次循环判断canceled的值的，所以在这种情况下用volatile不能让生产者停下来。
                    // 相反如果用interrupt语句来中断，即使生产者处于阻塞状态，仍然能够感受到中断信号，并做响应处理。
                    if (num % 50 == 0) {
                        storage.put(num);
                        System.out.println("volatileBooleanNot " + num + "是50的倍数,被放到仓库中了。");
                    }
                    num++;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("volatileBooleanNot 生产者结束运行");
            }
        }
    }

    static class Consumer {
        BlockingQueue storage;
        public Consumer(BlockingQueue storage) {
            this.storage = storage;
        }
        public boolean needMoreNums() {
            if (Math.random() > 0.97) {
                return false;
            }
            return true;
        }
    }

5 如何选择interrupt和boolean标志位去停止线程？

答：interrupt()和boolean标志位的原理是一致的。除非是用到了系统方法时(如:sleep) 或者 使用阻塞队列在线程中执行put()时发生阻塞，使用interrupt()；否则，建议使用boolean标志位，性能更优，毕竟interrupt使用JNI有一定的开销。

相关阅读：

volatile的boolean无法处理长时间阻塞的情况


————————————————
版权声明：本文为CSDN博主「一枚-狗子」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/chenliguan/article/details/110325209 

码上得天下
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
python 如何停止一个死循环的线程
01-19
那什么是多线程？提到多线程这里要说两个概念，就是串行和并行，搞清楚这个，我们才能更好地理解多线程。 所谓串行，其实是相对于单条线程来执行多个任务来说的，我们就拿下载文件来举个例子：当我们下载多个文件时...
【多线程】——停止线程的三种方式
热门推荐
漫漫长途，终有回转；余味苦涩，终有回甘
04-28 3万+
前提    停止线程是在多线程开发时非常重要的方式，掌握线程的停止可以对线程的停止进行有效的处理。停止线程在Java中不像break那样干脆，而需要一些技巧性。停止线程的方式有三种，分别展示一下方式一使用退出标识，使得线程正常退出，即当run方法完成后进程终止。public void run() { while(flag){ //do something } }利用...
线程停止的三种方式超详细
zzf1233的博客
02-24 3679
线程停止的几种方式 1、简单粗暴法Stop 此方法已经废弃，不建议使用，jdk帮助文档有如下解释 1.1、从代码执行结果层面解释 package com.study.test; public class ThreadStopTest { public static void main(String[] args) throws InterruptedException { StopTest stopTest = new StopTest(); stopTest.s
如何停止一个线程？
贾欣晓的博客
06-26 4298
停止线程在java语言中并不像break语句那样干脆，还需要一些技巧性的处理。停止一个线程意味着在线程处理完任务之前停止正在做的操作，也就是放弃当前的操作，虽然这看起来非常简单，但是必须做好防范措施，以便达到预期的效果。停止一个线程可以使用Thread.stop()方法，但不推荐使用此方法，虽然它确实可以停止一个正在运行的线程，但是这个方法是不安全的，而且是被弃用作废的。大多数情况下，停止一个线程使用Thread.interrupt()方法，但这个方法不会终止一个正在运行的线程，还需要加入一个判断才可以完成
深度解析线程的正确停止方法
Qynwang的博客
05-26 1286
使用interrupt方法请求中断，而不是强制终止线程，是合作机制。这样，被请求中断的线程可以自主决定，处理自己的逻辑。好处是，可以保证数据安全，来得及清理，能够保证数据完整性。
停止线程有哪些方法？
qq_42933931的博客
02-16 1344
关键字
C#停止线程的方法
09-03
主要介绍了C#停止线程的方法,实例分析了C#正确停止线程的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
Java使用ExecutorService来停止线程服务
08-19
主要介绍了Java使用ExecutorService来停止线程服务，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java安全停止线程的方法详解
08-25
主要介绍了java安全停止线程的方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
面试官：如何终止线程？有几种方式？
12-21
使用标志位终止线程就是定义一个boolean型的标志位 ，在线程的run方法中根据这个标志位是为true还是为false来判断是否终止，这种情况多用于while循环中。 class StopThread extends Thread { //标志位 private ...
终止线程的四种方法
霓虹深处
07-26 1599
正常运行结束 程序运行结束，线程自动结束。 使用退出标志退出线程 一般 run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的 运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如： 最直接的方法就是设一个 boolean 类型的标志，并通过设置这个标志为 true 或 false 来控制 while 循环是否退出，代码示例...
线程终止的 4 种方式
古城的博客
06-27 5378
这个也是最常见的，指线程体执行完成，线程自动结束。在一般情况下，在 run 方法执行完毕的时候，线程会正常结束。然而，有些线程是后台线程，需要长时间运行，只有在系统满足某些特殊条件后，才能退出这些线程。这时可以使用一个变量来控制循环，比如设置一个 Boolean 类型的标志，并通过设置这个标志为 true 或 false 来控制 while 循环是否退出。 在上面的代码中定义了一个退出的表示 exit，exit 的默认值为 false。在定义 exit 时使用了一个 Java 的关键字 volatile，这
终止线程 4 种方式
Be Like
06-26 1万+
1、正常运行结束 程序运行结束，线程自动结束。 2、使用退出标志退出线程 一般 run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如： 最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while 循环是否退出，代码示例： public class ThreadSafe extends Thread { public volatile b
面试官：如何停止一个正在运行的线程
养歌的博客
01-12 2744
停止一个线程意味着在任务处理完任务之前停掉正在做的操作，也就是放弃当前的操作。停止一个线程可以用Thread.stop() 方法。 使用 stop 方法中止线程 public class ThreadTest{ static class Thread1 extends Thread { @Override public void run() { for (int i = 0; i < 500000; i++) {
如何正确地结束一个线程
马一凡的博客
01-02 1万+
为什么不用stop()方法 一般来说，当一个线程的方法体执行完，这个方法就会结束了。我们一般不直接使用stop方法来终止线程，这可能会导致业务逻辑不完整或者破坏原子性的操作，一段代码可能用来输出某些重要的信息，在方法的执行中使用stop方法终止线程，会使得输出的信息破坏或者不完整；在原子操作比如重入锁的使用时，当一个线程对象多次获得锁会使得计数加一，接下来需要以相同的次数释放锁，别的线程才能获得锁...
终止线程的三种方式
陈常杰的博客
10-09 1911
停止一个线程通常意味着在线程处理任务完成之前停掉正在做的操作，也就是放弃当前的操作。 在 Java 中有以下 3 种方法可以终止正在运行的线程： 使用退出标志，使线程正常退出，也就是当 run() 方法完成后线程中止。 使用 stop() 方法强行终止线程，但是不推荐使用这个方法，该方法已被弃用。 使用 interrupt 方法中断线程。 使用标志位终止线程 在 run() 方法执行完毕后，该线程就终止了。但是在某些特殊的情况下，run() 方法会被一直执行；比如在服务端程序中可能会使用 while(tr
线程停止（stop/intrrupt)
sophia__yu的博客
11-11 3676
使一个线程停止有下列三种方式： 使用标记位（设置flag）停止线程; 调用stop方法强制停止线程; Thread类的interrupt方法; 一：使用falg停止线程 ////使用标记位 class Mythread3 implements Runnable { private boolean flag=true; public void run() { ...
4.如何终止线程
纵横千里 捭阖四方 的专栏
08-24 4698
本文介绍了线程终止的问题 ，特别是阻塞线程的终止。主线程想让子线程停止要通过interrupt给子线程发一个信号，告诉要中断了，而不是强制将其中断。触发复位是为了让子线程保持原来的状态，是否中断则有子线程在catch中决定。如果不处理就不中断，如果要中断就是再执行一次Thread.currentThread().interrupt();
python thread 线程里面有死循环，应该怎么停止这个线程？给出代码
最新发布
06-07
一个常见的方法是使用一个共享变量来控制线程的运行状态。在主线程中设置共享变量的值，线程在运行时检查该变量的值，以决定是否继续运行或停止。 以下是一个简单的示例代码： ```python import threading import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值