【并发编程】线程终止方式

朴灿烈づ我的快乐病毒、 2022-03-22 11:50 229阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]（java-concurrent）

# 概述 #

中断可以理解为线程的一个标记位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。

中断好比其他线程对该线程打了个招呼，其他线程通过调用线程的 interrupt() 方法对其进行中断操作。

线程通过检测自身是否被中断来进行响应，线程通过方法 isInterrupted() 来进行判断是否被中断，

也可以调用静态方法 Thread.interrupted() 对当前线程的中断标识位进行复位。如果该线程已经处于

终结状态，即使该线程被中断过，在调用该线程对象的 isInterrupted() 时依旧会返回 false。

# 一 interrupt() 方法 #

使用interrupt方法来中断线程，并不能马上就让线程中断，使用interrupt方法只是在当前线程中打了一个停止的标记，

并不是真正的停止线程。

package com.jpeony.concurrent.thread;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
     * 使用interrupt方法来中断线程，并不能马上就让线程中断，使用interrupt方法只是在当前线程中打了一个停止的标记，并不是真正的停止线程。
     *
     * @author yihonglei
     */
    public class InterruptMethod extends Thread {
        private final static Logger logger = LoggerFactory.getLogger(IsInterruptMethod.class);
    
        @Override
        public void run() {
            long start = System.currentTimeMillis();
            // 循环50万次
            for (int i = 0; i < 100000; i++) {
                logger.info("i = {}", i + 1);
            }
            System.out.println("执行耗时:" + (System.currentTimeMillis() - start) / 1000);
        }
    
        public static void main(String[] args) {
            try {
                InterruptMethod thread = new InterruptMethod();
                // 启动InterruptMethod线程
                thread.start();
                // main线程休眠2秒
                Thread.sleep(2000);
                // 调用interrupt中断线程
                thread.interrupt();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**运行结果**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70][]

我们从打印结果可以看到确实输出了 10 万条日志，说明 interrupt 并没有让线程中断，因为当 InterruptMethod 线程启动后，

过两秒钟的时间就调用 interrupt 中断线程，但是输出耗时 3 秒。

# 二 interrupted()、isInterrupted()方法 #

在Thread类中，提供了两个方法判断线程是否停止。

## 1、interrupted() ##

判断当前线程是否已经中断，同时执行结束时清除线程状态并将线程状态标识为默认状态 false，状态复位。

public static boolean interrupted()

**测试当前线程是否中断**

package com.jpeony.concurrent.thread;
    
    /**
     * 判断当前线程是否已经中断，同时执行结束时清除线程状态并将线程状态标识为默认状态false。
     *
     * @author yihonglei
     */
    public class InterruptedMethod extends Thread {
        @Override
        public void run() {
            // 循环50万次
            for (int i = 0; i < 500000; i++) {
                System.out.println("i = " + (i + 1));
            }
        }
    
        public static void main(String[] args) {
            try {
                InterruptedMethod thread = new InterruptedMethod();
                // 启动InterruptMethod线程
                thread.start();
                // main线程休眠2秒
                Thread.sleep(2000);
                // 调用interrupt中断线程
                thread.interrupt();
                // 判断是否已经中断
                System.out.println("是否停止1:" + interrupted());
                // 判断是否已经中断
                System.out.println("是否停止2:" + interrupted());
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

拷贝控制台运行结果到文本编辑器，搜索"是否停止"，分别找到两个打印结果：

是否停止1:false

是否停止2:false

判断结果均为 false，说明当前线程"main"从未中断过。

**验证 interrupted() 清空线程状态：**

package com.jpeony.concurrent.thread;
    
    /**
     * @author yihonglei
     */
    public class Run {
        public static void main(String[] args) {
            Thread.currentThread().interrupt();
            System.out.println("是否停止1:" + Thread.interrupted());
            System.out.println("是否停止2:" + Thread.interrupted());
            System.out.println("线程执行结束！");
        }
    }

**运行结果：**

是否停止1:true

是否停止2:false

线程执行结束！

第一次检测的时候，拿到线程中断，所以为 true，但是第二次为 false，因为第一次的时候线程状态 true 被清除，

恢复为默认 false。

## 2、isInterrupted() ##

判断线程是否已经中断，不清除线程的中断状态标识状态。

public boolean isInterrupted()

**测试当前线程是否中断：**

package com.jpeony.concurrent.thread;
    
    /**
     * 判断线程是否已经中断，不清除线程的中断状态标识状态。
     *
     * @author yihonglei
     */
    public class IsInterruptMethod extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 500000; i++) {
                System.out.println("i = " + (i + 1));
            }
        }
    
        public static void main(String[] args) {
            try {
                IsInterruptMethod thread = new IsInterruptMethod();
                thread.start();
                Thread.sleep(1000);
                thread.interrupt();
                System.out.println("是否停止1:" + thread.isInterrupted());
                System.out.println("是否停止2:" + thread.isInterrupted());
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

运行结果拷贝到文本编辑器，搜索"是否停止"，找到运行结果:

是否停止1:true

是否停止2:true

根据打印的结果，isInterrupted() 方法并没有清除线程状态标识，所以打印了两个 true。

# 三 停止线程的方法 #

**1、异常法**

判断线程中断状态为 true 时，抛线程中断异常。

**2、休眠停止**

让线程处于休眠状态，再调用 interrupt()，线程抛异常中断。

**3、暴力停止**

调用 stop 方法，该方法已废弃，不推荐使用。

**4、使用 return 停止**

方法中的代码遇到 return 时，该方法运行结束，利用这种手段，也能达到线程停止的效果。

## **1、异常法** ##

package com.jpeony.concurrent.thread;
    
    /**
     * 异常法：判断线程中断状态为true时，抛线程中断异常。
     *
     * @author yihonglei
     */
    public class ExceptionMethod extends Thread {
        @Override
        public void run() {
            try {
                for (int i = 0; i < 500000; i++) {
                    // 判断线程是否中断
                    if (interrupted()) {
                        System.out.println("线程已经停止，退出代码执行");
                        throw new InterruptedException();
                    }
                    System.out.println("i = " + (i + 1));
                }
    
                System.out.println("跳出for循环，执行for循环后的代码");
            } catch (Exception ignored) {
            }
        }
    
        public static void main(String[] args) {
            try {
                ExceptionMethod exceptionMethod = new ExceptionMethod();
                exceptionMethod.start();
    
                Thread.sleep(1000);
                exceptionMethod.interrupt();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**运行结果**

![Center][]

从运行结果可以看出，线程启动后执行 1 秒钟的时间，调用 interrupt 方法，中断了线程。

## 2、休眠停止 ##

package com.jpeony.concurrent.thread;
    
    /**
     * 休眠停止：让线程处于休眠状态，再调用interrupt()，线程抛异常中断。
     *
     * @author yihonglei
     */
    public class SleepInterruptThread extends Thread {
        @Override
        public void run() {
            try {
                System.out.println("begin time = " + System.currentTimeMillis());
                // 长时间休眠，测试休眠中调用interrupt方法
                Thread.sleep(500000);
                System.out.println("end time = " + System.currentTimeMillis());
            } catch (InterruptedException ex) {
                System.out.println("catch......");
                ex.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            try {
                SleepInterruptThread sleepInterruptThread = new SleepInterruptThread();
                sleepInterruptThread.start();
    
                Thread.sleep(2000);
                sleepInterruptThread.interrupt();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**运行结果**

![70][]

## 3、暴力停止 ##

package com.jpeony.concurrent.thread;
    
    /**
     * 暴力停止：调用stop方法，stop方法已经被废弃,同时使用stop方法强制停止线程，
     * 会导致某些收尾程序未完成，对象"解锁"，导致数据不同步，出现数据不一致问题。
     *
     * @author yihonglei
     */
    public class StopThread extends Thread {
        private int count = 1;
    
        @Override
        public void run() {
            try {
                while (true) {
                    count++;
                    System.out.println("count = " + count);
                    Thread.sleep(2000);
                }
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    
        public static void main(String[] args) {
            try {
                StopThread stopThread = new StopThread();
                stopThread.start();
    
                Thread.sleep(8000);
                stopThread.stop();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

## 4、使用 return 停止 ##

package com.jpeony.concurrent.thread;
    
    /**
     * return停止：方法中的代码遇到return时，该方法运行结束，利用这种手段，也能达到线程停止的效果。
     *
     * @author yihonglei
     */
    public class ReturnInterruptThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 500000; i++) {
                if (interrupted()) {
                    System.out.println("通过return，实现线程停止效果!");
                    return;
                }
                System.out.println(" i = " + (i + 1));
            }
        }
    
        public static void main(String[] args) {
            try {
                ReturnInterruptThread returnThread = new ReturnInterruptThread();
                returnThread.start();
    
                Thread.sleep(2000);
                returnThread.interrupt();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }

**运行结果**

![70 1][]

通过return方式停止程序会导致代码中存在多个return，使得代码不纯净，不整洁，可读性降低，一般采用异常法停止线程，干净利索。

# 参考文献 #

JDK 源码；

《Java 并发编程的艺术》；

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lobF9qeHk_size_16_color_FFFFFF_t_70]: /images/20220322/e7808b94ce1646a08cdb9b3c2ccbc140.png
[Center]: /images/20220322/0d3b6af24d274efdb18b16ab8d4a00cc.png
[70]: /images/20220322/f9f87e63032441bf9ebdcaf1c58f07bd.png
[70 1]: /images/20220322/7b44d452426d4254a9fec80a2c56834f.png