[Java知识库]Java并发基础学习（二）——线程的停止和中断

前言

上一篇博客简单介绍了线程启动的方式，这一篇博客打算介绍一下如何停止线程，Java中停止线程相对来说就比较麻烦了，如何正确的停止线程其实也是一个比较常见的面试考题，需要详细总结一下。

线程停止的原理

Java中线程的停止并不是像关闭一个开关一样，直接停止线程，Java中的线程停止原理有点类似于计算机组成原理中对中断的处理，首先关闭中断标志位，让后响应中断，然后处理中断。

Java中线程的处理也可以看成大致的这个过程——**线程本身响应外部的中断通知，然后将中断标志位复位，但是什么之后线程停止，由线程本身自己决定。**这也是Java中最好的停止线程的方式。

如何正确停止线程

其实不同状态的线程，对中断信号的响应是不同的，因此在不同的线程逻辑的停止方式也有细微的差异。这里简单总结一下。

正常运行状态的线程停止

实例代码

/**
 * autor:liman
 * createtime:2021/9/9
 * comment: run方法内没有sleep或wait方法的时候停止线程
 */
public class RightWayStopThreadWithoutSleep implements Runnable {

    @Override
    public void run() {
        int num = 0;
        //while判断的时候，调用当前线程的isInterrupted判断中断标志位是否有中断的信号
        while (!Thread.currentThread().isInterrupted()
                && num <= Integer.MAX_VALUE / 2) {
            if (num % 10000 == 0) {
                System.out.println(num + " is 10000 的倍数");
            }
            num++;
        }
        System.out.println("任务运行结束");
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new RightWayStopThreadWithoutSleep());
        thread.start();
        Thread.sleep(1000);//主线程睡眠1秒
        thread.interrupt();//给子线程发出中断信号
    }
}

正常的运行结果如下：

sleep状态的线程停止

如果目标线程本身是在sleep的阻塞状态，这个时候目标线程响应中断的方式也是有些许差异的

/**
 * autor:liman
 * createtime:2021/9/9
 * comment: run方法内有sleep或wait方法的时候停止线程
 */
public class RightWayStopThreadWithSleep {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = ()->{
            int num = 0;
            while(num<=300 && !Thread.currentThread().isInterrupted()){
                if(num %100 ==0){
                    System.out.println(num + " is 100的倍数");
                }
                num++;
            }
            try {
                Thread.sleep(5000);//执行完运算之后，进入sleep的阻塞状态
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(1000);//主线程睡眠1秒
        thread.interrupt();//给子线程发出中断信号
    }
}

运行结果

在sleep阻塞状态中的线程，响应中断的方式比较特殊，是直接抛出异常。 这也是Java为什么强制需要我们对sleep抛出的异常进行处理的原因。目标线程在sleep的时候，依旧能响应中断。

需要说明一下的是，上面的实例中，每次循环的时候，在while的时候，都判断了一下中断的标志位，如果sleep在while循环体中（也就是每次循环sleep一下），这种情况下while循环的开头，是不需要判断中断标志位的

/**
 * autor:liman
 * createtime:2021/9/9
 * comment: 如果在执行过程中，每次执行都会sleep或者wait等待，则不需要每次迭代中都判断中断标记
 */
public class RightWayStopThreadWithSleepEveryLoop {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = () -> {
            try {
                int num = 0;
                while (num <= 10000 ) {//循环体中有sleep，外部可以不用判断中断标志位
                    if (num % 100 == 0) {
                        System.out.println(num + " is 100的倍数");
                    }
                    num++;
                    Thread.sleep(10);//执行完运算之后，等待1秒
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        };
        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(5000);
        thread.interrupt();
    }
}

还有一个需要注意的是，sleep响应中断之后，中断标志位会复位（这一点和计算机组成原理中的中断响应太像了），将上述代码中while循环外的try-catch放入到循环体内部，即可看到不同的效果

/**
 * autor:liman
 * createtime:2021/9/9
 * comment:while里头放try/catch，则会导致中断失效
 */
public class CanInterrupt {

    public static void main(String[] args) throws InterruptedException {
        Runnable runnable = ()->{
            int num = 0;
            while(num <= 10000 && !Thread.currentThread().isInterrupted()){//即使这里判断中断标志位也并不能停止线程
                if(num % 100 == 0){
                    System.out.println(num + " is 100 的倍数");
                }
                num++;
                try {
                    Thread.sleep(10);//sleep响应中断，catch处理之后，会复位中断标志位
                } catch (InterruptedException e) {
                    e.printStackTrace();//这里响应中断之后，中断标志位被复位，线程并不能被停止
                }
            }
        };

        Thread thread = new Thread(runnable);
        thread.start();
        Thread.sleep(1000);
        thread.interrupt();
    }
}

运行结果如以下动图所示：

在响应中断之后，目标线程并没有终止，而是继续欢快的运行，所以在停止sleep阻塞状态中的线程的时候，需要注意中断标志位的复位问题。

较好的停止线程的方式

针对sleep本身对中断标志位清除的问题，简单总结了一下正确停止线程的方法。

1、子方法的中断异常需要抛出

先说问题，如果将中断的异常，在子方法中进行处理，则相关异常在处理完成之后，中断标志位复位。并不能完成中断的

public class ProdRightWayStopThread implements Runnable{
    @Override
    public void run() {
        while(true) {
            System.out.println("running");
            catchInterruptInMethod();
        }
    }

    //目标线程调用的子方法
    private void catchInterruptInMethod() {
		try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {//子方法内部处理中断的异常。
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ProdRightWayStopThread());
        thread.start();
        Thread.sleep(900);
        thread.interrupt();//通知目标线程，中断。
    }
}

运行结果和上面的代码参不多，一直running，输出一行异常信息之后，继续running，如果这是生产，则相关异常的日志会淹没在海量的日志数据中……

因此较好的方式，是强制在run方法中处理子方法的相关异常（不只是InterruptedException）

/**
 * autor:liman
 * createtime:2021/9/11
 * comment:生产中正确的停止线程的方式之一 强制要求子方法抛出InterruptedException的异常
 */
public class ProdRightWayStopThread implements Runnable{
    @Override
    public void run() {
        while(true) {
            System.out.println("running");
            try {
                catchInterruptInMethod();
            } catch (InterruptedException e) {
                e.printStackTrace();//这里可以做相关的异常处理。
                return;
            }
        }
    }

    private void catchInterruptInMethod() throws InterruptedException {
        //线程的调用方法中，sleep的时候针对中断异常的处理并没有抛出
            //sleep模拟子线程在运行
            Thread.sleep(1000);
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ProdRightWayStopThread());
        thread.start();
        Thread.sleep(900);
        thread.interrupt();
    }
}

2、恢复中断标志位

如果子方法确实无法抛出中断的相关异常，可以通过恢复中断标志位来进行，还是基于上述的实例进行优化

/**
 * autor:liman
 * createtime:2021/9/11
 * comment:生产中正确的停止线程的方式之一：在子方法中重新通知中断，以便于父方法中能够检查到刚才发生了中断。
 */
@Slf4j
public class ProdRightWayStopThreadResetInterrupt implements Runnable {
    @Override
    public void run() {
        while (true) {
            if(Thread.currentThread().isInterrupted()){
                log.info("thread is interrupted，线程中断，运行终止");
                break;
            }
            System.out.println("running");
            catchInterruptInMethod();
        }
    }

    private void catchInterruptInMethod() {
        //线程的调用方法中，sleep的时候针对中断异常的处理并没有抛出
        //sleep模拟子线程在运行
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            log.error("收到中断信号，处理中断，信息为:{}",e);
            //重新通知中断，在父run方法中，正常响应中断即可。
            Thread.currentThread().interrupt();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ProdRightWayStopThreadResetInterrupt());
        thread.start();
        Thread.sleep(10000);
        thread.interrupt();
    }
}

总的来说线程停止较好的方式就两种，无非就是将中断异常抛出，或者重新开中断。

几种错误的停止方式

1、stop，suspend和resume

这几种方式其实已经被弃用了，自然是错误的，相比之前介绍的几种比较优雅的方式，这种方式暴力的多，并且会造成脏数据，这些脏数据会对程序的后续运行产生很大的问题，这个就不做具体的实例了。suspend是带着锁进入到阻塞，容易造成死锁，因此被丢弃

2、volatile修饰的标记位

关于采用volatile修饰的变量，来停止线程，这个在有些博客或者书籍上归纳为正确的停止方式，但是在目标线程阻塞的时候，这种方式并不能正确停止线程。

/**
 * autor:liman
 * createtime:2021/9/11
 * comment: volatile的局限性，无法停止线程的实例
 * 当线程阻塞的时候，volatile无法停止线程
 * 生产者生产数据很快，消费者消费数据很慢，所以阻塞队列满了之后，生产者会阻塞，这种情况 volatile是不生效的
 */
@Slf4j
public class WrongWayVolatileCannotStop{

    public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue dataQueue = new ArrayBlockingQueue(10);
        Producer producer = new Producer(dataQueue);
        Thread producerThread = new Thread(producer);
        producerThread.start();
        Thread.sleep(10000);//让生产者生产数据

        Consumer consumer = new Consumer(dataQueue);
        while(consumer.canConsumer(dataQueue)){
            log.info("数据:{} 被消费者消费了",consumer.dataQueue.take());
            Thread.sleep(100);//模拟消费者对获取到的数据进行处理
        }
        log.info("消费者不再需要更多数据，给生产者发送中断信号");

        producer.canceled = true;//消费者数据消费完成，停止生产者
    }


}

@Slf4j
class Producer implements Runnable{

    public volatile boolean canceled = false;

    BlockingQueue dataQueue;

    public Producer(BlockingQueue dataQueue) {
        this.dataQueue = dataQueue;
    }

    @Override
    public void run() {
        int num = 0;
        try {
            while (num <= 100000 && !canceled) {
                if (num % 100 == 0) {
                    dataQueue.put(num);//数据放入队列
                    log.info("num : {} 是100的倍数", num);
                }
                num++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            log.info("【生产者】运行结束");
        }
    }
}

@Slf4j
class Consumer{

    BlockingQueue dataQueue;

    public Consumer(BlockingQueue dataQueue) {
        this.dataQueue = dataQueue;
    }

    /**
     * 判断是否能进一步的消费数据
     * @param dataQueue
     * @return
     */
    public boolean canConsumer(BlockingQueue dataQueue){
        //if(dataQueue.size()<=0){
        if(Math.random()>0.95){//消费者不需要太多数据，不一定会消费所有生产者的数据
            return false;
        }
        return true;
    }
}

上述代码有点复杂，是模拟了一个简单的生产者和消费者的简单实例，但是消费者消费数据比较慢，由于消费者消费数据不及时，导致生产者最终会进入到阻塞状态，在队列数据满了之后，生产者阻塞在dataQueue.put()方法中了，这个时候，生产者是无法判断代码中volatile修饰的标志位变量的，因此依旧阻塞，无法停止。运行结果如下：

从运行结果来看，线程并没有终止。因此这种情况volatile并不适用，如果要正确停止上述线程，用interrupt的方法即可。

interrupt相关方法

有很多方法与interrupt方法比较相似，具体如下

1、static boolean interrupted()

2、boolean isInterrupted()

3、Thread.interrupted()的目的对象

第一个静态方法（注意，这个方法不是interrupt），判断线程是否中断，返回判断结果之后，会将线程的中断状态置为false

第二个方法，判断线程是否中断，返回判断结果之后，不会将线程的中断状态置为false

第三个方法，需要注意的是，这个其实就是第一个方法，只是调用的时候不是通过具体的对象来调用，而是通过Thread类进行调用。

/**
 * autor:liman
 * createtime:2021/9/11
 * comment:各种interrupt关联方法的结果【
 */
public class RightWayInterruptMethod {
    public static void main(String[] args) throws InterruptedException {

        Thread threadOne = new Thread(new Runnable() {
            @Override
            public void run() {
                for (; ; ) {
                }
            }
        });

        // 启动线程
        threadOne.start();
        //设置中断标志
        threadOne.interrupt();
        //获取中断标志
        System.out.println("isInterrupted: " + threadOne.isInterrupted());
        //输出当前线程的中断标志结果（当前线程是main，不管调用这个方法的对象是什么，因为这个方法是静态方法）
        System.out.println("isInterrupted: " + threadOne.interrupted());
        //输出当前线程的中断标志结果（当前线程是main）
        System.out.println("isInterrupted: " + Thread.interrupted());
        //获取中断标志
        System.out.println("isInterrupted: " + threadOne.isInterrupted());
        threadOne.join();
        System.out.println("Main thread is over.");
    }
}

运行结果

第二行和第三行输出结果，不论调用interrupted方法的是对象还是Thread类，其判断结果都是当前线程的中断标志位的结果。而当前的运行线程是main线程，故而是false。

常见的面试问题

1、如何停止线程

用interrupt来操作，而不是所谓的stop和volatile等方式，interrupt本身在一定程度上可以保证数据安全，要想达到正确停止线程的效果，除了简单发出中断信号还不行，还需要目标线程进行配合，通知目标线程对中断异常也要做一个正取处理，不能在子方法中将静默处理，如果在子方法中处理也要重新开中断。volatile在一定场景下可以正常停止，但是在目标线程阻塞的时候，volatile变量停止线程的操作，就不那么优秀了。

2、如何处理不可中断的阻塞

interrupt方法并不是万能的，在目标线程进行socket io操作的时候，线程长期处于阻塞状态，但是这种阻塞并没有一个通用的解决方案，这种时候，我们就需要设置IO超时的时间，让线程能做到可以响应中断。

可以响应中断的方法

除了sleep方法，还有些方法，目标线程在执行该指定方法的时候，虽然不是运行状态，但是也可以响应中断。这些方法如下：

1、Object.wait()/wait(long)/wait(long,int)
2、Thread.sleep(long)/sleep(long,int)
3、Thread.join()/join(long)/join(long,int)
4、java.util.concurrent.BlockingQueue.take()/put(E)
5、java.util.concurrent.locks.Lock.lockInterruptibly()
6、java.util.concurrent.CountDownLatch.await()
7、java.util.concurrent.CyclicBarrier.await()
8、java.util.concurrent.Exchanger.exchange(V)
9、java.nio.channels.InterruptibleChannel相关方法
10、java.nio.channels.Selector的相关方法

总结

关于停止，掌握上面梳理的内容，应该差不多了，后续总结线程的几种状态