Java多线程（二）

Java多线程（二）

上一篇“Java多线程（一）”主要讨论的是线程的创建，本章主要讨论停止线程。

1.概述

停止一个线程意味着在线程处理完任务之前停掉正在做的操作，也就是放弃当前的操作。虽然这看起来很简单，但是必须做好防范措施，以便达到预期的效果。
在java中有以下3中方法可以终止正在运行的线程：

• （1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
• （2）使用stop方法强行终止线程，但是不推荐使用这个方法，因为此方法已经过时。
• （3）使用interrupt方法中断线程。

2.使用stop()停止线程

使用stop()停止线程是非常暴力的，但不推荐用它，虽然它确实可以停止一个正在运行的线程，但这个方法是不安全的，而且已经是被弃用作废的，在将来的java版本中，这个方法将不可用或不被支持。

public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        for (int i = 0; i < 5000; i++) {
            System.out.println("i=" + (i + 1));
        }
    }

    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(10);
            myThread.stop();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

JDK源码中将stop()标识为过时（Deprecated）：

 @Deprecated
    public final void stop() {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            checkAccess();
            if (this != Thread.currentThread()) {
                security.checkPermission(SecurityConstants.STOP_THREAD_PERMISSION);
            }
        }
...

stop()方法的不良后果

1)调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作，包括在 catch 或 finally 语句中的，并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获)，因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。
2)调用 stop() 方法会立即释放该线程所持有的所有的锁，导致数据得不到同步，出现数据不一致的问题。

3.使用interrupt方法中断线程

tips:使用interrupt()方法仅仅是在当前线程中打了一个停止的标记，并不是真正的停止线程。
所以使用interrupt()方法中断线程还需要结合判断线程是不是停止的，如果判断线程是中断状态再停止线程。Java的SDK提供了两种方法来判断线程是否停止：

• 1）this.interrupted():测试当前线程是否已经是中断状态，执行后具有将状态标志清除为false的功能。
• 2）this.isInterrupted():测试线程Thread对象是否已经是中断状态，但不清除状态标志。

3.1 两种判断线程停止状态方式的区别

public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(100);
            myThread.interrupt();
            System.out.println("是否停止1："+myThread.interrupted());
            System.out.println("是否停止1："+myThread.interrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

输出结果：

是否停止1：false
是否停止1：false

代码执行myThread.interrupt()给myThread线程打上停止标记。然后用interrupted()来判断线程状态。但从输出结果来看，线程并未停止，这也就印证了interrupted()的解释：测试当前线程是否已经中断，当前线程是main线程，从未中断过。
将上面的代码稍作修改：

public class TestInterrupt {
    public static void main(String[] args) {
        try {
            MyThread myThread = new MyThread();
            myThread.start();
            Thread.sleep(100);
//            myThread.interrupt();
            Thread.currentThread().interrupt();
            System.out.println("是否停止1："+Thread.interrupted());
            System.out.println("是否停止1："+Thread.interrupted());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

是否停止1：true
是否停止1：false

修改后的代码使用Thread.currentThread().interrupt();中断了main线程，并且第一次执行interrupted()的结果为true，第二次执行的结果为false，这也印证了interrupted()具有将状态标志清除的功能。
再来看看isInterrupted()方法：

    public static void main(String[] args) {
          MyThread myThread = new MyThread();
          myThread.start();
          myThread.interrupt();
          System.out.println("是否停止1："+myThread.isInterrupted());
          System.out.println("是否停止1："+myThread.isInterrupted());
    }

输出结果：

是否停止1：true
是否停止1：true

从输出结果可以看到，方法isInterrupted()并未清除状态标志，所以打印了两个true。

3.2 中断线程的方法——异常法

public class InterruptMyThread extends Thread {
    @Override
    public void run() {
        super.run();
        try{
            for(int i=0;i<50000;i++){
                if(this.interrupted()){
                    System.out.println("线程是停止状态了。。。。");
                    throw new InterruptedException();
                }
                System.out.println(i);
            }
        }catch (InterruptedException e){
            System.out.println("线程停止，跳出for循环，进入catch");
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try {
            InterruptMyThread interruptMyThread = new InterruptMyThread();
            interruptMyThread.start();
            Thread.sleep(1000);
            interruptMyThread.interrupt();
        } catch (InterruptedException e) {
            System.out.println("main catch~");
            e.printStackTrace();
        }
    }
}

输出结果：

线程是停止状态了。。。。
线程停止，跳出for循环，进入catch
java.lang.InterruptedException
    at com.panda.thread.stop.interrupt.InterruptMyThread.run(InterruptMyThread.java:11)

3.3 中断线程的方法——return

将方法interrupt()与return结合使用也能实现停止线程的效果。

public class InterruptThreadByReturn extends Thread {
   @Override
   public void run() {
       super.run();
       while (true){
           if(this.isInterrupted()){
               System.out.println("线程停止了!");
               return;
           }
           System.out.println("timer="+System.currentTimeMillis());
       }
   }

   public static void main(String[] args) throws InterruptedException {
       InterruptThreadByReturn interruptThreadByReturn = new InterruptThreadByReturn();
       interruptThreadByReturn.start();
       Thread.sleep(2000);
       interruptThreadByReturn.interrupt();
   }
}

输出结果：

...
timer=1611474998138
timer=1611474998138
timer=1611474998138
timer=1611474998138
线程停止了!

不过还是建议使用“异常法”来实现线程的停止，因为可以在catch块中可以对异常的信息进行相关的处理，而且使用异常流能更好、更方便地控制程序的运行流程。

3.4 在沉睡中停止

如果在sleep状态下停止某一线程，会抛出InterruptedException异常，并清除停止状态值。

public class InterruptThreadinSleep extends Thread{
    @Override
    public void run() {
        super.run();
        try{
            System.out.println("begin");
            Thread.sleep(200000);
            System.out.println("end");
        }catch (InterruptedException e){
            System.out.println("进入catch--"+this.isInterrupted());
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        try{
            InterruptThreadinSleep interruptThreadinSleep = new InterruptThreadinSleep();
            interruptThreadinSleep.start();
            Thread.sleep(200);
            interruptThreadinSleep.interrupt();
        }catch (InterruptedException e){
            System.out.println("main catch!");
            e.printStackTrace();
        }
    }
}

输出结果：

begin
进入catch--false
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.panda.thread.stop.interrupt.InterruptThreadinSleep.run(InterruptThreadinSleep.java:9)