精华内容
下载资源
问答
  • Java停止线程的四种方法

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

    欢迎访问我的个人博客:学教府

    一、线程停止基础知识

    • interrupted(): 测试当前线程是否已经中断。该方法为静态方法,调用后会返回boolean值。不过调用之后会改变线程的状态,如果是中断状态调用的,调用之后会清除线程的中断状态。
    • isInterrupted(): 测试线程是否已经中断。该方法由对象调用
    • interrupt(): 标记线程为中断状态,不过不会中断正在运行的线程。
    • stop(): 暴力停止线程。已弃用。

    二、停止线程方法1:异常法停止

       线程调用interrupt()方法后,在线程的run方法中判断当前对象的interrupted()状态,如果是中断状态则抛出异常,达到中断线程的效果。

       如下示例:

    MyThread.java
    public class MyThread extends Thread {
    
        @Override
        public void run() {
            try {
                for (int i = 0; i < 500000; i++) {
                    if (MyThread.interrupted()){
                        System.out.println("已经是停止状态了,我要退出了!");
                        throw new InterruptedException();
                    }
                    System.out.println("i = " + (i+1));
                }
    
                System.out.println("如果我被输出了,则代表线程没有停止");
            } catch (InterruptedException e) {
                System.out.println("在MyThread类中的run方法中被捕获");
                e.printStackTrace();
            }
        }
    }
    
    Main.java
    /**
     * 根据中断状态退出for循环
     * @Author: xjf
     * @Date: 2019/5/25 13:27
     */
    public class Main {
    
        public static void main(String[] args) {
            try {
                MyThread myThread  = new MyThread();
                myThread.start();
                Thread.sleep(100);
                myThread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            System.out.println("end!");
        }
    }
    
    结果如下:
    i = 19115
    i = 19116
    i = 19117
    i = 19118
    i = 19119
    end!
    已经是停止状态了,我要退出了!
    在MyThread类中的run方法中被捕获
    java.lang.InterruptedException
    	at com.book.interrupt_exit.MyThread.run(MyThread.java:15)
    
    Process finished with exit code 0
    

    三、停止线程方法2:在沉睡中停止

    1. 先将线程sleep,然后调用interrupt标记中断状态,interrupt会将阻塞状态的线程中断。会抛出中断异常,达到停止线程的效果。如下示例:
    MyThread.java
    public class MyThread extends Thread {
    
        @Override
        public void run() {
            try {
                System.out.println("run-----------start");
                Thread.sleep(5000);
                System.out.println("run-----------end");
            } catch (InterruptedException e) {
                System.out.println("在沉睡中被停止!进入catch,线程的是否处于停止状态:" + this.isInterrupted());
                e.printStackTrace();
            }
    
        }
    }
    
    Main.java
    public class Main {
    
        public static void main(String[] args) {
            try {
                MyThread myThread = new MyThread();
                myThread.start();
                Thread.sleep(2000);
                System.out.println("状态:"+MyThread.interrupted());
                myThread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    
    结果
    run-----------start
    状态:false
    java.lang.InterruptedException: sleep interrupted
    在沉睡中被停止!进入catch,线程的是否处于停止状态:false
    	at java.lang.Thread.sleep(Native Method)
    	at com.book.sleep_interrupt.MyThread.run(MyThread.java:13)
    
    1. 线程先调用interrupt标记中断状态,然后线程再睡眠。会抛出中断异常,达到停止线程的效果。如下:
    MyThread1.java
    public class MyThread1 extends Thread {
    
        @Override
        public void run() {
            try {
    
                for (int i = 0; i < 100000; i++) {
                    System.out.println("i = " + (i+1));
                }
                System.out.println("run begin");
                //interrupt是做一个中断标记,当时不会去中断正在运行的线程,当该线程处于阻塞状态时就会进行中断
                //因此,先进行interrupt后,再遇到sleep阻塞时,才会进行中断
                Thread.sleep(200000);
                System.out.println("run end");
    
            } catch (InterruptedException e) {
                System.out.println("先停止,再遇到了sleep! 进入catch!");
                e.printStackTrace();
            }
        }
    }
    
    Main1.java
    public class Main1 {
    
        public static void main(String[] args) {
    
            MyThread1 myThread1 = new MyThread1();
            myThread1.start();
            myThread1.interrupt();
            System.out.println("end!");
        }
    }
    
    结果:
    i = 99993
    i = 99994
    i = 99995
    i = 99996
    i = 99997
    i = 99998
    i = 99999
    i = 100000
    run begin
    先停止,再遇到了sleep! 进入catch!
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at com.book.sleep_interrupt.MyThread1.run(MyThread1.java:19)
    

    四、停止线程方法3:stop()暴力停止

       线程调用stop()方法会被暴力停止,方法已弃用。该方法会有不好的后果:

    1. 强制让线程停止有可能使一些请理性的工作得不到完成。
    2. 对锁定的对象进行了“解锁”,导致数据得不到同步的处理,出现数据不一致的问题(比如一个方法加上了synchronized,并在其中进行了一个长时间的处理,而在处理结束之前该线程进行了stop(),则未完成的数据将没有进行到同步的处理)

    五、停止线程方法4:使用return停止线程

    • 调用interrupt标记为中断状态后,在run方法中判断当前线程状态,如果为中断状态则return,能达到停止线程的效果。

    备注:建议使用“抛异常”的方法来实现线程的停止,因为在catch块中还可以将异常向上抛,使线程停止的事件得以传播

    参考:《Java多线程编程核心技术》

    展开全文
  • Java停止线程运行的三种方式

    千次阅读 2017-03-14 20:26:50
    Java终止正在运行的线程的方式有如下三种 1 使用退出标志,使线程正常退出,也就是run方法完成后线程终止 2 使用stop方法强行终止线程(已过时),但是不推荐使用这个方法 3 使用interrupt方法中断线程 1 使用退出...

    Java终止正在运行的线程的方式有如下三种

    • 1 使用退出标志,使线程正常退出,也就是run方法完成后线程终止
    • 2 使用stop方法强行终止线程(已过时),但是不推荐使用这个方法
    • 3 使用interrupt方法中断线程

    1 使用退出标志,使线程正常退出,也就是run方法完成后线程终止

    当run方法正常执行完,线程也就停止了,当有循环时,可设置一个标志变量,为真时运行,否则退出循环,主要代码如下:

    public void run() {
        while(flag){
            //do something
        }
    }

    想要终止运行时,只需设置flag值为false即可。

    2 使用stop方法强行终止线程(已过时)

    使用stop()方法能立即停止线程,但是可能使一些请理性工作得不到完成。另一种情况就是对锁锁定的对象经行了“解锁”,导致数据得不到同步的处理,出现不一致的问题

    3 使用interrupt方法中断线程

    值得注意的是,interrupt()方法并不能真正停止线程,而是在当前线程打了一个停止的标记,可用以下方法停止线程。

    public void run() {
            while (true) {
                if (this.interrupted())
                    break;
                System.out.println("running");
            }
            System.out.println("退出线程");
        }

    调用interrupt()方法,this.interrupted()结果为true,退出循环,但会继续执行System.out.println(“退出线程”);然后正常退出线程。可以采用抛异常的方式终止线程,代码如下

    public void run() {
        try {
            while (true) {
                if (this.interrupted()) {
                    throw new InterruptedException();
                }
                System.out.println("running");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    展开全文
  • java停止线程的方法

    千次阅读 2012-03-16 22:19:20
    首先我们先查看API文档,找到Thread这个类,从这个类中我们...用 Thread.stop 来终止线程将释放它已经锁定的所有监视器(作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果)。如果以前受这些监视器保护的任

    首先我们先查看API文档,找到Thread这个类,从这个类中我们找到了stop()这个方法。但是,

    stop

    @Deprecated
    public final void stop()
    已过时。 该方法具有固有的不安全性。用 Thread.stop 来终止线程将释放它已经锁定的所有监视器(作为沿堆栈向上传播的未检查 ThreadDeath 异常的一个自然后果)。如果以前受这些监视器保护的任何对象都处于一种不一致的状态,则损坏的对象将对其他线程可见,这有可能导致任意的行为。stop 的许多使用都应由只修改某些变量以指示目标线程应该停止运行的代码来取代。目标线程应定期检查该变量,并且如果该变量指示它要停止运行,则从其运行方法依次返回。如果目标线程等待很长时间(例如基于一个条件变量),则应使用 interrupt 方法来中断该等待。

    我们知道了stop()这个方法不安全,那怎么来停止线程呢,我想大家都在思考这个问题。我写了2个实例,供大家参考。

    No.1——

    public class ThreadDemo2{
    public static void main(String arges[]){
    Dog d=new Dog();
    Thread t=new Thread(d);
    t.start();
    }
    }
    class Dog implements Runnable{
    int times=0;
    public void run(){
    while(true){
    try{
    Thread.sleep(1000);
    }catch(Exception e){}
    times++;
    System.out.println("当前是:"+times);
    if(times==5){
    break;
    }
    }
    }
    }

    No.2——

    public class ThreadDemo3{
    public static void main(String arges[]){
    Cat c=new Cat();
    Thread t1=new Thread(c);
    t1.start();
    }
    }
    class Cat implements Runnable{
    int times=0;
    boolean t=true;
    public void run(){
    while(t){
    try{
    Thread.sleep(1000);
    }catch(Exception e){}
    System.out.println("hello");
    times++;
    if(times==5){
    this.stop();
    }
    }
    }
    public void stop(){
    t=false;
    }
    }

    展开全文
  • 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多线程停止线程

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

    千次阅读 2015-07-19 18:43:35
    停止线程Java语言中并不像break语句那样干脆,需要一些技巧性的处理。 一、 异常法 采用异常法来停止一个线程,首先我们需要了解一下两个方法的用法: 1、interrupt()方法 public class MyThread extends Thread{ ...
  • Java多线程编程-停止线程 暂停线程

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

    千次阅读 2017-03-04 20:48:04
    总结如下几种方式使线程停止执行: (1)共享bool类型变量方式; (2)调用线程interrupt方式,同时通过isInterrupted方式判断线程是否被停止,若停止则终止循环操作(线程类中循环外没有其他操作); (3)调用...
  • java多线程之启动,停止线程

    千次阅读 2016-10-19 22:34:33
    停止线程 线程的优先级 守护线程 线程的启动 启动线程的两种方式 继承Thread类 线程代码: package com.sun.thread; public class MyThread extends Thread { @Override public void run() { super
  • 万字图解Java线程

    万次阅读 多人点赞 2020-09-06 14:45:07
    java线程我个人觉得是javaSe中最难的一部分,我以前也是感觉学会了,但是真正有多线程的需求却不知道怎么下手,实际上还是对多线程这块知识了解不深刻,不知道多线程api的应用场景,不知道多线程的运行流程等等,...
  • Java线程:彻底搞懂线程池

    万次阅读 多人点赞 2019-07-09 19:27:00
    熟悉Java线程编程的同学都知道,当我们线程创建过多时,容易引发内存溢出,因此我们就有必要使用线程池的技术了。 目录 1 线程池的优势 2 线程池的使用 3 线程池的工作原理 4 线程池的参数 4.1 任务队列...
  • Java多线程03_线程状态、优先级、用户线程和守护线程 线程方法: ...停止线程: 不推荐JDK提供的stop()、destory()方法 【已废弃】 推荐让线程正常停止,不要死循环! 建议使用一个标志位进行终止,当
  • 主要是 Java 并发, 停止线程的方法分析
  • 停止线程,也许我们首先会有一种错感,觉得使用Thread.stop()或者Thread.interrupt()与Thread.interrupted()等组合就能退出线程了。可是在实际运用过程中,这样真的可以达到安全退出线程吗?下面就由我带大家逐一...
  • java多线程之-----停止线程

    千次阅读 2017-10-28 16:39:44
    java中有以下三种方式可以终止正在运行的线程:使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。 使用stop方法强行终止线程,但是...停止线程—异常法新建Mythread类继承Threadpublic class MyThread
  • 那么,很自然地,我们就会想到线程启动并执行之后,什么时候才能停止或者什么时候让它停止呢?这就是笔者想在这篇文章中和大家分享的主题。 Java线程中有一个已经封装好的方法—–stop()方法。这个方法是在早期...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,500
精华内容 73,400
关键字:

java停止线程

java 订阅