精华内容
下载资源
问答
  • java线程池停止线程 停止线程 (Stopping a thread) As we know that there are no direct or shortcut ways to stop thread in Java. 众所周知,在Java中没有直接或快捷的方式来停止线程。 As we know thread in ...

    java线程池停止线程

    停止线程 (Stopping a thread)

    • As we know that there are no direct or shortcut ways to stop thread in Java.

      众所周知,在Java中没有直接或快捷的方式来停止线程。

    • As we know thread in java stops when the execution of run() method completed normally or thread stops if it raises an exception in the meanwhile of Thread completion.

      众所周知,当run()方法的执行正常完成时,java中的线程会停止;如果在线程完成的同时它引发异常,则线程会停止。

    • In previous versions of Java JDK there exists a method of Thread class named "stop" but this method is deprecated in later versions so it does not support in later versions of Java.

      在Java JDK的早期版本中,存在一个名为“ stop”的Thread类方法,但是该方法在更高版本中不推荐使用,因此在更高版本的Java中不支持。

    • Java does not provide some direct methods to stop thread in Java but there are some control methods defined in java JDK earlier versions and the names of the method are given below:

      Java没有提供一些直接的方法来停止Java中的线程,但是在Java JDK早期版本中定义了一些控制方法,该方法的名称如下:

      1. stop()
      2. suspend()
      3. resume()
    • All the methods given above are deprecated so it does not support in later versions of Java.

      上面给出的所有方法均已弃用,因此在更高版本的Java中不支持。

    • We will see how to stop a thread implicitly Java JDK stops a thread implicitly if and only if either a thread run() method completes it execution normally or if a thread raises an exception in the meanwhile.

      我们将看到如何隐式停止线程Java JDK仅在以下情况下隐式停止线程:(仅当线程run()方法正常完成了该线程的执行)或同时线程引发异常。

    • Now, we will see how to stop a thread manually: we can stop a thread manually in two ways:

      现在,我们将看到如何手动停止线程:我们可以通过两种方式手动停止线程:

      1. With the help of volatile boolean variable
      2. With the help of interrupt() method

    Now we will elaborate on each way one by one is given below...

    现在,我们将在下面逐一详细说明每种方式...

    With the help of volatile boolean variable

    借助volatile布尔变量

    • In the first step, we will declare a volatile boolean variable in a thread.

      第一步,我们将在线程中声明一个易失的布尔变量。

    • In the second step initially, we will assign the value of the volatile boolean variable as true.

      首先,在第二步中,我们将volatile布尔变量的值分配为true。

    • In the third step, we will define a job inside while loop and passing parameter of the volatile boolean variable in while loop and we will keep loop inside run() method. By using loop the thread will continue to run until volatile boolean variable becomes false.

      在第三步中,我们将在while循环中定义作业,并在while循环中传递易失布尔变量的参数,并将循环保留在run()方法中。 通过使用循环,线程将继续运行,直到volatile布尔变量变为false。

    • In the fourth step, we will define another method named "stopThread()" inside a thread and in this method, we will set volatile boolean variable is set to false to stop the thread.

      在第四步中,我们将在线程内定义另一个名为“ stopThread()”的方法,在此方法中,我们将volatile布尔变量设置为false以停止线程。

    • In the fifth or final step, we don’t need to do anything manually to stop the thread. To stop a thread we can simply call user-defined stopThread() method to stop the thread.

      在第五步或最后一步,我们不需要手动执行任何操作即可停止线程。 要停止线程,我们可以简单地调用用户定义的stopThread()方法来停止线程。

    Example:

    例:

    // Java program to stop a thread with the help of 
    // volatile boolean variable
    
    class ChildThread extends Thread {
        // intially assign boolean variable with value as true
        volatile boolean thread_stop = true;
    
        // this method is defined to stop a thread
        public void stopThread() {
            thread_stop = false;
        }
    
        // this loop will continue until boolean variable become false
        public void run() {
            while (thread_stop) {
                System.out.println("Child Thread Started");
            }
            System.out.println("Child Thread Ended");
        }
    }
    
    class Main {
        public static void main(String[] args) {
            ChildThread ct = new ChildThread();
            ct.start();
            try {
                Thread.sleep(100);
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
    
            // this method will be called to stop a thread
            ct.stopThread();
        }
    }
    
    

    Output

    输出量

    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    .
    .
    .
    .
    .
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Ended
    
    

    With the help of interrupt() method

    借助interrupt()方法

    We will use readymade interrupt() method to stop a thread.

    我们将使用现成的interrupt()方法来停止线程。

    When we call interrupt method on a thread object and it will assign the interrupted status of a thread and this status can be generated by the interrupted() method.

    当我们在线程对象上调用中断方法时,它将分配线程的中断状态,并且此状态可以由interrupted()方法生成。

    Example:

    例:

    // Java program to stop a thread by using interrupt() method
    
    class ChildThread extends Thread {
        // this loop will continue until boolean variable become false
        public void run() {
            while (!Thread.interrupted()) {
                System.out.println("Child Thread Started");
            }
            System.out.println("Child Thread Ended");
        }
    }
    
    class Main {
        public static void main(String[] args) {
            ChildThread ct = new ChildThread();
            ct.start();
            try {
                Thread.sleep(100);
            } catch (Exception ex) {
                System.out.println(ex.getMessage());
            }
    
            // this method will be called to interrupt a thread
            ct.interrupt();
        }
    }
    
    

    Output

    输出量

    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    .
    .
    .
    .
    .
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Started
    Child Thread Ended
    
    
    

    翻译自: https://www.includehelp.com/java/how-to-stop-a-thread-in-java.aspx

    java线程池停止线程

    展开全文
  • Java多线程编程-停止线程 暂停线程

    千次阅读 2017-04-05 16:16:08
    停止线程停止线程是在多线程开发中很重要的技术点,个人总结停止线程有下面三种方法 *

    一 停止线程

    停止线程是在多线程开发中很重要的技术点,个人总结停止线程有下面三种方法:

    1.使用interrupt()方法停止线程

    1.1 单独用interrupt()是不能停止线程的,此方法仅仅是在当前线程中打了一个停止线程的标记,并不是真正的停止线程,当运行下面的测试代码时,会发现,线程并未停止。

    /**
     * 
     *
     *<p>Description:测试Interrupt方法停止线程</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5上午11:14:38
     *
     */
    public class TestThread extends Thread{
        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 50000; i++) {
                System.out.println("i:"+i);
            }
        }
    }
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            TestThread thread = new TestThread();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
            System.out.println("THE thread whether stop:"+thread.isInterrupted());
        }
    
    }

    判断线程是否停止的两个方法:
    this.interrupted():测试当前线程是否已中断
    测试当前线程是否已经中断,线程的中断状态由该方法清除,也就是如果连续两次调用该方法,则第二次调用将返回false(在第一次调用已清除了其中断状态之后,且第二次调用检验完中断状态前,当前线程再次中断的情况除外)。

    this.isInterrupted():测试线程Thread对下岗是否已是中断状态
    不清除状态标志

    1.2 使用interrupt()与return结合实现线程的停止

    /**
     * 
     *
     *<p>Description:测试Interrupt方法和retun停止线程</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5上午11:36:57
     *
     */
    public class TestThread extends Thread{
    
        @Override
        public void run() {
            while (true) {
                if(TestThread.interrupted()){
                    System.out.println("The thread is stop!");
                    return;
                }
                System.out.println("time="+System.currentTimeMillis());
            }
        }
    }
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            TestThread thread = new TestThread();
            thread.start();
            Thread.sleep(2000);
            thread.interrupt();
        }
    }

    这里写图片描述
    由上图看出,使用interrupt()与return结合实现线程的停止


    2 使用抛异常的方法停止线程

    /**
     * 
     *
     *<p>Description:使用异常停止线程</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5下午2:28:21
     *
     */
    public class TestThread extends Thread{
        @Override
        public void run() {
            super.run();
            try {
                for (int i = 0; i < 500000; i++) {
                    if(this.interrupted()){
                        System.out.println("The Thread had alreday stop,exit!");
                        throw new Exception();
                    }
                    System.out.println("i="+(i+1));
                }
                for (int j = 0; j < 50; j++) {
                    System.out.println("J="+(j+1));
                }
            } catch (Exception e) {
                System.out.println("TestThread Catch ");
                e.printStackTrace();
            }
        }
    
    }
    
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            try {
                TestThread myThread = new TestThread();
                myThread.start();
                Thread.sleep(2000);
                myThread.interrupt();
            } catch (Exception e) {
                System.out.println("Main Catch");
                e.printStackTrace();
            }
            System.out.println("End");
        }
    }
    

    这里写图片描述

    由程序运行结果图可以看出,在TestThread 类中,第二个for循环的代码没有执行,证明用抛异常的方法停止线程成功。


    3 使用stop()方法停止线程

    3.1 Thread.stop()已经被废除,为什么不建议使用呢,一个重要原因就是调用Thread.stop()方法停止线程时,会对锁定的对象进行“解锁”,导致数据得不到同步处理,出现数据不一致的问题。

    /**
     * 
     *
     *<p>Description:测试Stop()方法停止线程</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5上午11:52:22
     *
     */
    public class SynchronizedObject {
        private String username="xiaoming";
        private String password="123456";
        public String getUsername() {
            return username;
        }
        public void setUsername(String username) {
            this.username = username;
        }
        public String getPassword() {
            return password;
        }
        public void setPassword(String password) {
            this.password = password;
        }
        synchronized public void printString(String name,String pass){
            try {
                this.username=name;
                Thread.sleep(100000);
                this.password=pass;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
        }
    }
    
    public class MyThread extends Thread{
    
        public SynchronizedObject object;
        public MyThread(SynchronizedObject object){
            super();
            this.object=object;
        }
    
        @Override
        public void run() {
            object.printString("xiaohong", "654321");
        }
    
    }
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            SynchronizedObject object = new SynchronizedObject();
            MyThread myThread = new MyThread(object);
            myThread.start();
            Thread.sleep(100);
            myThread.stop();
            System.out.println(object.getUsername()+"=:"+object.getPassword());
    
        }
    
    }
    

    这里写图片描述

    由上图看出,使用stop()停止线程,出现了数据问题,所以,这个方法不建议大家使用。
    顺便说一下,调用stop()方法时会抛出java.lang.ThreadDeath异常,但是在通常情况下,此异常不需要显式地捕捉。

    二 暂停线程

    在java多线程编程中,暂停线程意味着此线程还可以恢复运行,可以用suspend()方法暂停线程,使用resume()方法恢复线程的执行,但是,使用suspend()与resume()方法时,如果使用不当,也会出现很多问题。
    2.1 线程的暂停与恢复

    /**
     * 
     *
     *<p>Description:测试线程的暂停与恢复</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5下午3:03:17
     *
     */
    public class TestThread extends Thread{
        private  int  i= 0;
    
        public int getI() {
            return i;
        }
        public void setI(int i) {
            this.i = i;
        }
    
        @Override
        public void run() {
            while (true) {
                i++;
            }
        }
    
    }
    
    
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            TestThread thread = new TestThread();
            thread.start();
            Thread.sleep(2000);
            thread.suspend();
            System.out.println("The Thread had alreday suspend:"+thread.getI());
            Thread.sleep(2000);
            System.out.println("The Thread had alreday suspend:"+thread.getI());
            thread.resume();
            System.out.println("The Thread resume:"+thread.getI());
            Thread.sleep(2000);
            thread.suspend();
            System.out.println("The Thread had alreday suspend:"+thread.getI());
            Thread.sleep(2000);
            System.out.println("The Thread had alreday suspend:"+thread.getI());
        }
    }
    

    2.2 suspend()与resume()方法的缺点-线程独占
    使用suspend()与resume()方法时,如果使用不当,极易造成公共的同步对象的独占,使其他线程无法访问公共同步对象

    /**
     * 
     *
     *<p>Description:测试线程的独占</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5下午3:39:46
     *
     */
    public class PrintStr {
        synchronized public void printString(){
            System.out.println("Begin");
            if(Thread.currentThread().getName().equals("a")){
                System.out.println("a thread suspend");
                Thread.currentThread().suspend();
            }
            System.out.println("End");
        }
    }
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            final PrintStr printStr = new PrintStr();
            Thread thread = new Thread(){
                @Override
                public void run() {
                    printStr.printString();
                }
            };
            thread.setName("a");
            thread.start();
            thread.sleep(1000);
            Thread threadTwo = new Thread(){
                @Override
                public void run() {
                    System.out.println("ThreadTwo is running ");
                    System.out.println("The method printString() had already locked with \"a\" thread,forever suspend");
                    printStr.printString();
                    System.out.println("threadTwo is end");
                }
            };
            threadTwo.start();
        }
    }

    这里写图片描述
    由上面示例程序的运行结果可以看出,“a”线程在执行printString()方法时执行了suspend()方法,独占了printString()方法,导致threadTwo 线程无法访问printString()方法。

    2.3 在使用suspend()与resume()方法时也容易出现因为线程暂停而导致数据不同步的情况,这个情况和stop停止线程导致数据不同步的情况类似。

    /**
     * 
     *
     *<p>Description:测试线程暂停而导致的数据不同步</p>
     *
     * @author:SongJia
     *
     * @date: 2017-4-5下午3:41:13
     *
     */
    public class User {
        private String name="xiaoming";
        private String password="123456";
        public void setValue(String name,String password){
            this.name=name;
            if(Thread.currentThread().getName().equals("a")){
                System.out.println("\"a\" thread stop");
                Thread.currentThread().suspend();
            }
            this.password=password;
        }
        public void printUsernameAndPassword(){
            System.out.println(name+":"+password);
        }
    }
    
    public class Run {
        public static void main(String[] args) throws InterruptedException {
            final User user = new User();
            Thread thread = new Thread(){
                @Override
                public void run() {
                    user.setValue("xiaohong", "654321");
                }
            };
            thread.setName("a");
            thread.start();
            thread.sleep(1000);
            Thread threadTwo = new Thread(){
                @Override
                public void run() {
                    user.printUsernameAndPassword();
                }
            };
            threadTwo.start();
        }
    }
    

    这里写图片描述
    由上面示例程序的运行结果可以看出,暂停线程之后,出现了数据不同步问题。

    展开全文
  • Java多线程停止线程

    2016-11-21 14:36:32
    停止线程是在多线程开发时很重要的技术点,大多数停止一个线程的操作使用Thread.interrupt()方法,但这个方法不会终止一个正在运行的线程,还需要加入一个判断才可以完成线程的停止。Thread.stop()方法也可以停止...

    停止线程是在多线程开发时很重要的技术点,大多数停止一个线程的操作使用Thread.interrupt()方法,但这个方法不会终止一个正在运行的线程,还需要加入一个判断才可以完成线程的停止。Thread.stop()方法也可以停止线程,但最好不用它。这个方法不安全并且已经被弃用了。

    这里写图片描述
    这里写图片描述

    上面的示例虽然停止了线程,但如果for语句下面还有语句,还是会继续运行的。

    这个时候可以使用抛出异常法来解决。
    这里写图片描述
    这里写图片描述

    用return+interrupt()结合使用也可以停止线程
    这里写图片描述

    如果线程在sleep状态下停止的话会抛出InterruptedException异常。

    展开全文
  • Java 如何正确停止线程

    千次阅读 2020-07-12 16:35:50
    如何正确停止线程? 文章目录如何正确停止线程?前言项目环境1.使用场景2.为什么不强制停止?而是通知、协作3.如何用 interrupt 停止线程?4.sleep 期间能否感受到中断?4.1 示例4.2 子方法签名抛异常,run() 强制 ...

    如何正确停止线程?

    前言

    从上一章《为什么说本质上只有一种实现线程的方式?》可以看出创建并启动一个线程比较简单,但是如果想要正确的停止一个线程就没那么容易了。

    本章主要讨论以下两个议题:

    • 如何正确停止一个线程?
    • 为什么用 volatile 标记位的停止方法是错误的?

    项目环境

    1.使用场景

    通常线程停止的方式:线程中的任务执行完成后自然停止。但是依然会有许多特殊的情况需要我们提前停止线程,比如:用户突然关闭程序,或程序运行出错重启等。

    在这种情况下,即将停止的线程在很多业务场景下仍然很有价值。尤其是我们想写一个健壮性很好,能够安全应对各种场景的程序时,正确停止线程就显得格外重要。

    对于 Java 而言,最正确的停止线程的方式是使用 interrupt。但 interrupt 仅仅起到通知被停止线程的作用,即修改线程是否被中断的状态,而不会真的停止线程。

    而对于被停止的线程而言,它感受到 interrupt 的中断信号之后,再根据实际的业务情况进行编码:

    • 既可以选择立即停止
    • 也可以选择一段时间后停止
    • 也可以选择压根不停止

    2.为什么不强制停止?而是通知、协作

    那么为什么 Java 不提供强制停止线程的能力呢?

    从设计原则上,Java 希望程序间能够相互通知、相互协作地管理线程,因为如果不了解对方正在做的工作,贸然强制停止线程就可能会造成一些安全的问题,为了避免造成问题就需要给对方一定的时间来整理收尾工作。比如:线程正在写入一个文件,这时收到终止信号,它就需要根据自身业务判断,是选择立即停止,还是将整个文件写入成功后停止,而如果选择立即停止就可能造成数据不完整,不管是中断命令发起者,还是接收者都不希望数据出现问题。

    3.如何用 interrupt 停止线程?

    明白 Java 停止线程的设计原则之后,我们看看如何用代码实现停止线程的逻辑。我们一旦调用某个线程的 interrupt() 之后,这个线程的中断标记位就会被设置成 true。每个线程都有这样的标记位,当线程执行时,应该定期检查这个标记位,如果标记位被设置成 true,就说明有程序想终止该线程。

    示例:

    public class ThreadInterruptDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new InterruptTask());
            thread.start();
            thread.sleep(1);
            thread.interrupt();
        }
    
        static class InterruptTask implements Runnable {
    
            @Override
            public void run() {
                int count = 0;
                while (!Thread.currentThread().isInterrupted()) {
                    count++;
                }
                System.out.println("循环次数:" + count + ",线程中断,中断信号:" + Thread.currentThread().isInterrupted());
    
            }
        }
    }
    

    执行结果:

    循环次数:5589,线程中断,中断信号:true
    

    以上结果可以看到循环 5589 次后,线程收到了中断信号(即 Thread.currentThread().isInterrupted() 返回的结果为 true),循环条件不满足,退出自旋,执行完程序,自动停止线程,这种就属于通过 interrupt 正确停止线程的情况。

    4.sleep 期间能否感受到中断?

    4.1 示例

    我们将上面的例子改下一下,在任务执行中,增加一个 sleep。

    public class ThreadInterruptSleepDemo {
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new InterruptTask());
            thread.start();
            thread.sleep(500);
            thread.interrupt();
        }
    
        static class InterruptTask implements Runnable {
    
            @Override
            public void run() {
                int count = 0;
                while (!Thread.currentThread().isInterrupted()) {
                    count++;
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("循环次数:" + count + ",线程中断,中断信号:" + Thread.currentThread().isInterrupted());
    
            }
        }
    }
    

    执行结果:

    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at com.csdn.threadbase.ThreadInterruptSleepDemo$InterruptTask.run(ThreadInterruptSleepDemo.java:25)
    	at java.lang.Thread.run(Thread.java:748)
    

    即使线程在休眠状态下,线程也可以感受到中断信号,并且会抛出一个 InterruptedException 异常,同时清除中断信号,将中断标记位设置成 false。所以抛出 InterruptedException 异常之后,线程还在继续执行,Thread.currentThread().isInterrupted() 返回值仍然是 false,并没有修改为 true。那么我们应该如何处理线程中的异常呢?下面介绍 两种处理方式

    4.2 子方法签名抛异常,run() 强制 try/catch

    假设我们的方法内调用了 sleep 或者 wait 等能响应中断的方法时,仅仅 catch 住异常是不够的。我们可以在方法签名中声明 throws InterruptedException。如果有其他线程在 run 方法中调用这个方法的时候,必须强制 try/catch 来进行处理。

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

    4.3 再次中断

    改下上面 4.1 的例子,在 catch 异常之后,再次中断当前线程。

        static class InterruptTask implements Runnable {
    
            @Override
            public void run()  {
                int count = 0;
                while (!Thread.currentThread().isInterrupted()) {
                    count++;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }
                System.out.println("循环次数:" + count + ",线程终端,中断信号:" + Thread.currentThread().isInterrupted());
            }
        }
    

    因为如果线程在休眠期间被中断,那么会自动清除中断信号。如果这时手动添加中断信号,中断信号依然可以被捕捉到。这样后续执行的方法依然可以检测到这里发生过中断,可以做出相应的处理,整个线程可以正常退出。

    4.4 小结

    我们在实际开发中不能盲目吞掉中断,如果不在方法签名中声明,也不在 catch 语句块中再次恢复中断,而是在 catch 中不作处理,我们称这种行为是“屏蔽了中断请求”。如果我们盲目地屏蔽了中断请求,会导致中断信号被完全忽略,最终导致线程无法正确停止。

    5.错误的停止方法

    首先,我们来看几种停止线程的错误方法。比如 stop(),suspend() 和 resume(),这些方法已经被 Java 直接标记为 @Deprecated(弃用)。为什么它们被弃用了呢?原因如下:

    • stop() 会直接把线程停止,这样就没有给线程足够的时间来处理想要在停止前保存数据的逻辑,任务戛然而止,会导致出现数据完整性等问题。

    • suspend() 和 resume() ,它们的问题在于如果线程调用 suspend(),它并不会释放锁,就开始进入休眠,但此时有可能仍持有锁,这样就容易导致死锁问题,因为这把锁在线程被 resume() 之前,是不会被释放的。

    6.volatile 标记位的停止方法

    示例:

    public class ThreadInterruptVolatileDemo {
    
        private static volatile boolean flag = false;
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new InterruptTask());
            thread.start();
            thread.sleep(500);
            flag = true;
        }
    
        static class InterruptTask implements Runnable {
    
            @Override
            public void run() {
                int count = 0;
                while (!flag) {
                    count++;
                }
                System.out.println("循环次数:" + count + ",线程中断");
            }
        }
    }
    

    使用 volatile 修饰的 flag 变量来控制线程中的逻辑,来达到停止线程的效果同样可以。

    这个例子的原理和使用 interrupt 来停止线程的原理差不多,但是需要注意的是 volatile 这种方法在某些特殊的情况下,比如线程被长时间阻塞的情况,就无法及时感受中断(即被 volatile 修饰的 flag 变量无法及时更新状态值)。

    7.总结

    本章我们介绍了如何正确停止线程的几种方式

    1.使用 interrupt 来请求中断线程,而不是直接中断,真正中断线程任务还是根据实际的业务场景,在任务中进行判断。

    2.使用 volatile 修饰的变量来控制线程的中断,但是不适用于所有场景。

    然后我们讨论了如何正确的处理线程中的异常,以及 stop(),suspend() 和 resume() 这些错误的停止线程的方法以及其原因。

    8.参考

    • 《Java 并发编程 78 讲》- 徐隆曦
    展开全文
  • 停止线程以及Threadlocal

    千次阅读 2018-10-25 20:49:59
    如何停止线程停止线程思路 1. 使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。 2. 使用stop方法强行终止线程(这个方法不推荐使用,因为stop和suspend、resume一样,也可能发生不可预料的结果)...
  • java多线程之启动,停止线程

    千次阅读 2016-10-19 22:34:33
    停止线程 线程的优先级 守护线程 线程的启动 启动线程的两种方式 继承Thread类 线程代码: package com.sun.thread; public class MyThread extends Thread { @Override public void run() { super
  • 主要讲解线程中断,以及停止线程的方式,并且进行了相关的代码演示。
  • * 1.stop():已过时,这种方法有固有的不安全性,强制停止线程,不论处于什么状态都会停止,就会导致线程的不安全。 * 2.run方法结束了,当线程中没有运行的代码时,线程就结束了,意味着任务结束,线程消失。 * ...
  • 使用ExecutorService来停止线程服务

    千次阅读 2020-04-08 09:57:04
    使用ExecutorService来停止线程服务 之前的文章中我们提到了ExecutorService可以使用shutdown和shutdownNow来关闭。 这两种关闭的区别在于各自的安全性和响应性。shutdownNow强行关闭速度更快,但是风险也更大,因为...
  • 停止线程的正确方式
  • 多线程的终止方法(停止线程

    千次阅读 2019-07-08 23:30:07
    停止线程是多线程中的一个重要技术点,本篇文章将对线程的停止操作进行详细讲解。 停止线程不能像for或while循环中使用break停止那样直接,而是需要一些技巧来终止。 如何判断线程已终止 Thread类中提供了两个...
  • 【多线程】——停止线程的三种方式

    万次阅读 热门讨论 2018-04-28 18:33:47
    前提 停止线程是在多线程开发时非常重要的方式,掌握线程的停止可以对线程的停止进行有效的处理。停止线程在Java中不像break那样干脆,而需要一些技巧性。停止线程的方式有三种,分别展示一下方式一使用退出标识,...
  • 优雅的停止线程

    2018-05-15 20:52:24
    在平常的开发中我们想打断一个正在blocking的线程,或者结束执行任务超时的线程可以通过下面的几种方式优雅的停止线程。、 1.利用标识符去停止一个线程 通过捕获到标识符的改变从而结束任务,结束线程。 2....
  • Java停止线程的四种方法

    千次阅读 2019-06-09 13:26:34
    一、线程停止基础知识 interrupted(): 测试当前线程是否已经中断。该方法为静态方法,调用后会返回boolean值。不过调用之后会改变线程的状态,如果是中断状态调用的,调用之后会...stop(): 暴力停止线程。已弃用。...
  • java 如何正确的停止线程

    千次阅读 2018-10-24 17:11:48
    目录java 如何正确的停止线程错误方式一:使用stop()代码示例:正确方式:使用退出标记另一种错误方式:interrupt() java 如何正确的停止线程 错误方式一:使用stop() stop()方法在jdk中被标记为@deprecated,并...
  • Java如何正确停止线程

    千次阅读 2018-08-16 20:57:10
    在多线程开发时,停止线程是很重要的一个技术,因此,如何正确停止一个线程,对于从事多线程开发的人员是很重要且十分必要的。 1. 什么是停止线程? 所谓停止线程,就是让一个正在处理任务的线程,停止继续执行,...
  • 多线程(四) 如何停止线程

    千次阅读 2018-07-24 18:53:32
    在Thread类中提供了可以停止线程的方法(包括杀死和挂起):  @Deprecated  public final void stop(){}  @Deprecated  public final void suspend(){}    stop 和 suspend 添加的有Deprecated注释,也即是该...
  • java多线程之-----停止线程

    千次阅读 2017-10-28 16:39:44
    在java中有以下三种方式可以终止正在运行的线程:使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。 使用stop方法强行终止线程,但是...停止线程—异常法新建Mythread类继承Threadpublic class MyThread
  • Java中停止线程执行的方法

    万次阅读 2015-06-27 15:51:29
    Java中停止线程执行的方法作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszs一、暂停或停止线程的理论在Java编程中,要暂停或停止当前正在运行的线程,有几种方法。对于把线程转入睡眠Sleep状态,使用...
  • 停止线程方法(interrupt)

    千次阅读 2018-05-06 22:52:20
    java中有三种停止线程方法1)使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。2)使用stop方法方法强行终止线程,但是不推荐使用这个方法,应为stop不安全而且已经被废弃的方法,还有suspend和resume...
  • http://blog.csdn.net/ssssssue 停止线程 测试interrupt中断线程 测试interrupt中断线程 public class Demo { public static void main(String[] args) { StopRunnable stopRunnable = new Stop
  • 停止线程 欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列...
  • JAVA之旅(十五)——JAVA之旅(十五)——多线成的生产者和消费者,停止线程,守护线程,线程的优先级,setPriority设置优先级,yield临时停止 我们接着多线程讲 一.生产者和消费者 什么是生产者和消费者?我们解释...
  • 根据线程名获取线程停止进程 线程的命名与获取名称方法 设置名称可以使用Thread类的如下方法: *构造方法:public Thread (Runnable Target,String name) *设置名字:public final void setName(String...
  • * 停止线程: * 第三种方式: * 如果读不到标记怎么办? * 比如说在任务中让线程处于阻塞状态,无法执行标记,释放执行资格。 * run方法没有结束,所以线程无法停止,所以线程也没有办法退出。 * * Thread...
  • 在开发多线程程序时,经常由于需要重新执行任务从而取消(停止)工作线程。C++11目前并没有很好的取消线程执行的机制。那么我们应该如何实现取消线程呢? 说明 C++11使用<future>库进行线程间数据通讯,也...
  • 通过抛出异常的方式停止线程

    千次阅读 2018-06-23 15:58:46
    /** * @ClassName: StopThreadByException * @Description:通过throw异常的方式停止线程(真正的停止了线程) * @author freeflying * @date 2018年6月23日 */ public class StopThreadByExcepti...
  • Qt停止线程的方法

    万次阅读 2015-11-25 21:11:07
    一、停止线程的方法有两种: 一种是使用标志位,这种方法最好,在while循环中使用标志位判断是否满足进行循环的条件,并在run函数结束时将stoped置为初始化的值false。 while (!stoped){  emit sendhandledata()...
  • 关于Java中停止线程执行的方法总结

    千次阅读 2015-11-12 22:15:34
    如何停止java的线程一直是开发多线程程序的一个非常头痛的问题,本文我们就来讨论一下关于Java中停止线程执行的方法,我们应该如何正确停止java中的线程。 Java中停止线程执行的方法 一、暂停或停止线程的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 350,430
精华内容 140,172
关键字:

如何停止线程