面试题:Java中如何停止线程的方法

 更新时间:2019年09月11日 15:33:52   作者:Java Geek Tech  
这篇文章主要介绍了Java中如何停止线程的方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

如何停止线程是Java并发面试中的常见问题,本篇文章将从答题思路到答题细节给出一些参考。

答题思路:

  • 停止线程的正确方式是使用中断
  • 想停止线程需要停止方,被停止方,被停止方的子方法相互配合
  • 扩展到常见的错误停止线程方法:已被废弃的stop/suspend,无法唤醒阻塞线程的volatile

1. 正确方式是中断

其实从逻辑上也很好理解的,一个线程正在运行,如何让他停止?

A. 从外部直接调用该线程的stop方法,直接把线程停下来。

B. 从外部通过中断通知线程停止,然后切换到被停止的线程,该线程执行一系列逻辑后自己停止。

很明显B方法要比A方法好很多,A方法太暴力了,你根本不知道被停止的线程在执行什么任务就直接把他停止了,程序容易出问题;而B方法把线程停止交给线程本身去做,被停止的线程可以在自己的代码中进行一些现场保护或者打印错误日志等方法再停止,更加合理,程序也更具健壮性。

下面要讲的是线程如何能够响应中断,第一个方法是通过循环不断判断自身是否产生了中断:

public class Demo1 implements Runnable{

  @Override
  public void run() {
    int num = 0;
    while(num <= Integer.MAX_VALUE / 2 && !Thread.currentThread().isInterrupted()){
      if(num % 10000 == 0){
        System.out.println(num);
      }
      num++;
    }
  }

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

在上面的代码中,我们在循环条件中不断判断线程本身是否产生了中断,如果产生了中断就不再打印

还有一个方法是通过java内定的机制响应中断:当线程调用sleep(),wait()方法后进入阻塞后,如果线程在阻塞的过程中被中断了,那么线程会捕获或抛出一个中断异常,我们可以根据这个中断异常去控制线程的停止。具体代码如下:

public class Demo3 implements Runnable {
  @Override
  public void run() {
    int num = 0;
    try {
      while(num < Integer.MAX_VALUE / 2){
        if(num % 100 == 0){
          System.out.println(num);
        }
        num++;
        Thread.sleep(10);
      }
    } catch (InterruptedException e) {//捕获中断异常,在本代码中,出现中断异常后将退出循环
      e.printStackTrace();
    }
  }

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

2. 各方配合才能完美停止

在上面的两段代码中已经可以看到,想通过中断停止线程是个需要多方配合。上面已经演示了中断方和被中断方的配合,下面考虑更多的情况:假如要被停止的线程正在执行某个子方法,这个时候该如何处理中断?

有两个办法:第一个是把中断传递给父方法,第二个是重新设置当前线程为中断。

先说第一个例子:在子方法中把中断异常上抛给父方法,然后在父方法中处理中断:

public class Demo4 implements Runnable{

  @Override
  public void run() {
    try{//在父方法中捕获中断异常
      while(true){
        System.out.println("go");
        throwInterrupt();
      }
    }catch (InterruptedException e) {
      e.printStackTrace();
      System.out.println("检测到中断,保存错误日志");
    }
  }

  private void throwInterrupt() throws InterruptedException {//把中断上传给父方法
    Thread.sleep(2000);
  }

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

第二个例子:在子方法中捕获中断异常,但是捕获以后当前线程的中断控制位将被清除,父方法执行时将无法感知中断。所以此时在子方法中重新设置中断,这样父方法就可以通过对中断控制位的判断来处理中断:

public class Demo5 implements Runnable{

  @Override
  public void run() {
    while(true && !Thread.currentThread().isInterrupted()){//每次循环判断中断控制位
      System.out.println("go");
      throwInterrupt();
    }
    System.out.println("检测到了中断,循环打印退出");
  }

  private void throwInterrupt(){
    try {
      Thread.sleep(2000);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();//重新设置中断
      e.printStackTrace();
    }
  }

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

讲到这里,正确的停止线程方法已经讲的差不多了,下面我们看一下常见的错误停止线程的例子:

3. 常见错误停止线程例子:

这里介绍两种常见的错误,先说比较好理解的一种,也就是开头所说的,在外部直接把运行中的线程停止掉。这种暴力的方法很有可能造成脏数据。

看下面的例子:

public class Demo6 implements Runnable{
  /**
   * 模拟指挥军队,以一个连队为单位领取武器,一共有5个连队,一个连队10个人
   */
  @Override
  public void run() {
    for(int i = 0; i < 5; i++){
      System.out.println("第" + (i + 1) + "个连队开始领取武器");
      for(int j = 0; j < 10; j++){
        System.out.println("第" + (j + 1) + "个士兵领取武器");
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      }
      System.out.println("第" + (i + 1) + "个连队领取武器完毕");
    }
  }

  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Demo6());
    thread.start();
    Thread.sleep(2500);
    thread.stop();
  }
}

在上面的例子中,我们模拟军队发放武器,规定一个连为一个单位,每个连有10个人。当我们直接从外部通过stop方法停止武器发放后。很有可能某个连队正处于发放武器的过程中,导致部分士兵没有领到武器。

这就好比在生产环境中,银行以10笔转账为一个单位进行转账,如果线程在转账的中途被突然停止,那么很可能会造成脏数据。

另外一个“常见”错误可能知名度不是太高,就是:通过volatile关键字停止线程。具体来说就是通过volatile关键字定义一个变量,通过判断变量来停止线程。这个方法表面上是没问题的,我们先看这个表面的例子:

public class Demo7 implements Runnable {

  private static volatile boolean canceled = false;

  @Override
  public void run() {
    int num = 0;
    while(num <= Integer.MAX_VALUE / 2 && !canceled){
      if(num % 100 == 0){
        System.out.println(num + "是100的倍数");
      }
      num++;
    }
    System.out.println("退出");
  }

  public static void main(String[] args) throws InterruptedException {
    Thread thread = new Thread(new Demo7());
    thread.start();
    Thread.sleep(1000);
    canceled = true;
  }
}

但是这个方法有一个潜在的大漏洞,就是若线程进入了阻塞状态,我们将不能通过修改volatile变量来停止线程,看下面的生产者消费者例子:

/**
 * 通过生产者消费者模式演示volatile的局限性,volatile不能唤醒已经阻塞的线程
 * 生产者生产速度很快,消费者消费速度很慢,通过阻塞队列存储商品
 */
public class Demo8 {
  public static void main(String[] args) throws InterruptedException {
    ArrayBlockingQueue storage = new ArrayBlockingQueue(10);

    Producer producer = new Producer(storage);
    Thread producerThread = new Thread(producer);
    producerThread.start();
    Thread.sleep(1000);//1s足够让生产者把阻塞队列塞满

    Consumer consumer = new Consumer(storage);
    while(consumer.needMoreNums()){
      System.out.println(storage.take() + "被消费");
      Thread.sleep(100);//让消费者消费慢一点,给生产者生产的时间
    }

    System.out.println("消费者消费完毕");
    producer.canceled = true;//让生产者停止生产(实际情况是不行的,因为此时生产者处于阻塞状态,volatile不能唤醒阻塞状态的线程)

  }
}

class Producer implements Runnable{

  public volatile boolean canceled = false;

  private BlockingQueue storage;

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

  @Override
  public void run() {
    int num = 0;
    try{
      while(num < Integer.MAX_VALUE / 2 && !canceled){
        if(num % 100 == 0){
          this.storage.put(num);
          System.out.println(num + "是100的倍数,已经被放入仓库");
        }
        num++;
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }finally {
      System.out.println("生产者停止生产");
    }
  }
}

class Consumer{
  private BlockingQueue storage;

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

  public boolean needMoreNums(){
    return Math.random() < 0.95 ? true : false;
  }
}

上面的例子运行后会发现生产线程一直不能停止,因为他处于阻塞状态,当消费者线程退出后,没有任何东西能唤醒生产者线程。

这种错误用中断就很好解决:

/**
 * 通过生产者消费者模式演示volatile的局限性,volatile不能唤醒已经阻塞的线程
 * 生产者生产速度很快,消费者消费速度很慢,通过阻塞队列存储商品
 */
public class Demo8 {
  public static void main(String[] args) throws InterruptedException {
    ArrayBlockingQueue storage = new ArrayBlockingQueue(10);

    Producer producer = new Producer(storage);
    Thread producerThread = new Thread(producer);
    producerThread.start();
    Thread.sleep(1000);//1s足够让生产者把阻塞队列塞满

    Consumer consumer = new Consumer(storage);
    while(consumer.needMoreNums()){
      System.out.println(storage.take() + "被消费");
      Thread.sleep(100);//让消费者消费慢一点,给生产者生产的时间
    }

    System.out.println("消费者消费完毕");
    producerThread.interrupt();
  }
}

class Producer implements Runnable{

  private BlockingQueue storage;

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

  @Override
  public void run() {
    int num = 0;
    try{
      while(num < Integer.MAX_VALUE / 2 && !Thread.currentThread().isInterrupted()){
        if(num % 100 == 0){
          this.storage.put(num);
          System.out.println(num + "是100的倍数,已经被放入仓库");
        }
        num++;
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }finally {
      System.out.println("生产者停止生产");
    }
  }
}

class Consumer{
  private BlockingQueue storage;

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

  public boolean needMoreNums(){
    return Math.random() < 0.95 ? true : false;
  }
}

4. 扩展

可能你还会问:如何处理不可中断的阻塞?

只能说很遗憾没有一个通用的解决办法,我们需要针对特定的锁或io给出特定的解决方案。对于这些特殊的例子,api一般会给出可以响应中断的操作方法,我们要选用那些特定的方法,没有万能药。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

相关文章

  • Java基于JavaMail实现向QQ邮箱发送邮件

    Java基于JavaMail实现向QQ邮箱发送邮件

    这篇文章主要为大家详细介绍了Java基于JavaMail实现向QQ邮箱发送邮件的相关资料,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2016-01-01
  • 高价值Java多线程面试题分析

    高价值Java多线程面试题分析

    Java 给多线程编程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。多线程是多任务的一种特别的形式,但多线程使用了更小的资源开销
    2022-03-03
  • 解析Nacos的API居然存在这么严重的漏洞

    解析Nacos的API居然存在这么严重的漏洞

    这篇文章主要介绍了Nacos的API居然存在这么严重的漏洞,Nacos为我们提供了大量API,但是这些API默认是没有开启认证的,直接可以访问,针对于这一点我们也都可以去验证一下,本文给大家详细讲解,感兴趣的朋友跟随小编一起看看吧
    2022-09-09
  • 简单了解Spring Framework5.0新特性

    简单了解Spring Framework5.0新特性

    这篇文章主要介绍了简单了解Spring Framework5.0新特性,涉及了核心框架修订,核心容器更新,使用Kotlin进行函数式编程等几个方面的介绍,具有一定参考价值,需要的朋友可以了解下。
    2017-11-11
  • Java硬币翻转倍数递增试算实例

    Java硬币翻转倍数递增试算实例

    这篇文章主要介绍了Java硬币翻转倍数递增试算实例,有需要的朋友可以参考一下
    2013-12-12
  • Java中IO流的BufferedOutputStream和FileOutputStream对比

    Java中IO流的BufferedOutputStream和FileOutputStream对比

    这篇文章主要介绍了Java中IO流的BufferedOutputStream和FileOutputStream对比,不带缓冲的操作,每读一个字节就要写入一个字节,由于涉及磁盘的IO操作相比内存的操作要慢很多,所以在读写的字节比较少的情况下,效率比较低,需要的朋友可以参考下
    2023-07-07
  • SpringBoot中的Spring Cloud Hystrix原理和用法详解

    SpringBoot中的Spring Cloud Hystrix原理和用法详解

    在Spring Cloud中,Hystrix是一个非常重要的组件,Hystrix可以帮助我们构建具有韧性的分布式系统,保证系统的可用性和稳定性,在本文中,我们将介绍SpringBoot中的Hystrix,包括其原理和如何使用,需要的朋友可以参考下
    2023-07-07
  • java处理csv文件上传示例详解

    java处理csv文件上传示例详解

    这篇文章主要为大家详细介绍了java处理csv文件上传示例,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2020-12-12
  • Springmvc基于fastjson实现导包及配置文件

    Springmvc基于fastjson实现导包及配置文件

    这篇文章主要介绍了Springmvc基于fastjson实现导包及配置文件,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-10-10
  • 解决JDK8的ParallelStream遍历无序的问题

    解决JDK8的ParallelStream遍历无序的问题

    这篇文章主要介绍了解决JDK8的ParallelStream遍历无序的问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2021-07-07

最新评论