Java线程停止_java父子线程全部停止

多线程中有三种方法可以停止线程

1. 设置标记位，可以使线程正常退出
2. 使用stop方法强制使线程退出，但是这个方法不太安全已经被废弃
3. 使用Thread类中的一个interrupt()可以中断线程

标记位

举例：

class MyThread implements Runnable{
    volatile boolean flag = true;
    int i = 0;
    @Override
    public void run() {
       while(flag){

           System.out.println(Thread.currentThread().getName()+ i++);
           try {
               sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

public class Test{
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"子线程");
        t1.start();
        sleep(2000);
        myThread.flag = false;
        System.out.println("结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果：

子线程0
子线程1
子线程2
结束

1
2
3
4
5

这个方法就是设置一个标记位，然后在主方法中对标记位进行修改，从而控制线程的运行。

stop方法

在JDK1.2以前可以使用stop()方法来停止线程。但是，JDK1.2之后，该方法就被废弃了。
为什么被废弃呢？
因为stop()方法太过直接，会强行把执行一半的线程终止。当在一个线程对象上调用stop()方法时，这个线程对象 所运行的线程就会立即停止，假如一个线程正在执行：synchronized void { x = 3; y = 4;} 由于方法是同步的，多个 线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中， 它也会马上stop了，这样就产生了不完整的残废数据。所以会导致程序工作在不确定的状态下造成数据的不同步。

interrupt方法

interrupt() 方法只是改变中断状态而已，它不会中断一个正在运行的线程。这一方法实际完成的是，给受阻塞的线 程发出一个中断信号，这样受阻线程就得以退出阻塞的状态。

在JVM中，每个线程都有一个与自己中断状态相关的Boolean属性，称为中断状态。可以通Thread.currentThread().isInterrupted()来获取当前线程的中断状态，初始值为false。

而interrupt()方法只会给线程设置一个为true的中断标志。

由于Thread.currentThread().isInterrupted()可以直接获取到中断状态所以有的人可能会写下面的代码：

不推荐：

class MyThread implements Runnable{
   
    int i = 0;
    @Override
    public void run() {
       while(!Thread.currentThread().isInterrupted()){

           System.out.println(Thread.currentThread().getName()+ i++);
       }
    }
}

public class Test{
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"子线程");
        t1.start();
        sleep(1);
        t1.interrupt();
        System.out.println("结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

运行结果：

子线程0
子线程1
子线程2
子线程3
子线程4
子线程5
子线程6
子线程7
结束
1
2
3
4
5
6
7
8
9

但是一般不推荐使用，因为如果线程当前状态处于非阻塞状态，那么仅仅是线程的中断标志被修改为true而已；如果线程当前状态为阻塞状态(使用了wait、sleep、join方法发导致线程阻塞)，那么在将中断设置为true后,interrupt()会在线程中抛出InterruptException异常、并且将线程的中断状态由true设置为false。
举例：

class MyThread implements Runnable{
    int i = 0;
    @Override
    public void run() {
       while(!Thread.currentThread().isInterrupted()){

           System.out.println(Thread.currentThread().getName()+ i++);
           try {
               sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
    }
}

public class Test{
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"子线程");
        t1.start();
        sleep(2000);
        t1.interrupt();
        System.out.println("结束");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行结果：

子线程0
子线程1
结束
java.lang.InterruptedException: sleep interrupted
子线程2
	at java.lang.Thread.sleep(Native Method)
	at www.bit.java.MyThread.run(Test.java:675)
	at java.lang.Thread.run(Thread.java:748)
子线程3
子线程4
子线程5
1
2
3
4
5
6
7
8
9
10
11

如上面代码所示：程序抛出异常，并且不会被中断。这就是因为sleep语句使线程阻塞，抛出异常，且中断标志会被程序自动清除重置为false。

正确写法：

lass MyThread implements Runnable{
    volatile boolean flag = true;
    int i = 0;
    @Override
    public void run() {
       while(flag){
           try {
               boolean bool = Thread.currentThread().isInterrupted();
               System.out.println(Thread.currentThread().getName()+ i++);
               sleep(1000);
           } catch (InterruptedException e) {
               /**
                * 这里退出阻塞状态，且中断标志被系统会自动清除
                * 重置为false
                */
               boolean bool = Thread.currentThread().isInterrupted();
               System.out.println("3.重置中断为" + bool);
               return ;
           }
       }
    }
}

public class Test{
    public static void main(String[] args) throws InterruptedException {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"子线程");
        t1.start();
        sleep(3000);
        t1.interrupt();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

运行结果：

子线程0
子线程1
子线程2
3.重置中断为false
1
2
3
4

通过上面的分析可以得出，调用线程类的interrupted方法，其本质只是设置该线程的中断标志，将中断标志设置为true，并根据线程状态决定是否抛出异常。

补充：Thread.interrupted()是获取并清除当前线程的状态，
Thread.currentThread().isInterrupted()只是获取当前线程的中断状态，并不清除当前线程的中断状态。