Java多线程编程中,如何优雅地终止线程?

上一篇 / 下一篇  2023-05-12 10:52:38

  Java线程中断(Interrupt)是Java语言的一个重要特性,它允许一个线程在另一个线程运行时发出信号,告诉该线程停止正在执行的操作。本篇博客将深入探讨Java线程中断的相关知识点,包括线程中断的基本原理、如何使用线程中断、如何处理线程中断等方面。
  1、线程中断的基本原理
  线程中断是一种协作式的机制,由一个线程向另一个线程发出请求,要求它停止执行某个操作。通常情况下,当一个线程调用了另一个线程的interrupt()方法时,被中断线程会收到一个InterruptedException异常。这个异常的出现并不意味着线程已经终止,只是表示有一个中断请求需要被处理。被中断线程可以选择如何响应中断请求,可以继续执行任务,也可以立即停止执行。
  线程中断的基本原理涉及到两个重要的概念:中断标志位和中断异常。每个线程对象都有一个中断标志位,用于表示当前线程是否被中断。当一个线程调用了另一个线程的interrupt()方法时,实际上是将被中断线程的中断标志位设置为true。被中断线程在执行某些操作时,会检查自身的中断标志位,如果该标志位被设置为true,那么线程就应该停止执行。
  但是,线程不会在任意时间停止执行。如果线程正在等待某个条件,或者正在执行一个IO操作,那么它将继续等待或者执行IO操作,直到该操作完成或者等待超时。这时,线程并不会立即响应中断请求,而是会抛出一个InterruptedException异常,并清除中断标志位,以便其他线程可以再次发起中断请求。
  2、如何使用线程中断
  线程中断是Java中线程控制的重要手段之一,可以用来协调多个线程之间的工作。以下是Java中线程中断的常见用法:
  (1)中断线程
  中断线程是最常见的线程中断用法之一,它允许一个线程在另一个线程运行时发出信号,告诉该线程停止正在执行的操作。Java中提供了两种方式中断线程:
  调用Thread.interrupt()方法:该方法会将当前线程的中断标记设置为true,表示该线程已经被中断。
  调用Thread.currentThread().isInterrupted()方法:该方法会返回当前线程的中断标记,用于判断当前线程是否被中断。
  下面是一个示例代码,演示如何中断线程:
  class MyThread extends Thread {
      public void run() {
          while (!isInterrupted()) { // 检查中断标记
              // 执行一些操作...
          }
          System.out.println("Thread interrupted");
      }
  }
  public class Main {
      public static void main(String[] args) throws InterruptedException {
          MyThread thread = new MyThread();
          thread.start();
          Thread.sleep(1000); // 等待1秒钟
          thread.interrupt(); // 中断线程
          
          thread.join(); // 等待线程执行完毕
      }
  }
  在上面的示例代码中,我们创建了一个MyThread线程,并启动它。然后,等待该线程执行1秒钟后中断它。被中断线程会检查自身的中断标记,如果该标记被设置为true,那么线程就停止执行。
  (2)中断阻塞的线程
  当一个线程正在执行阻塞(Blocking)操作时(如等待I/O完成、等待获取锁、等待条件变量满足等),线程可能会陷入无限期的等待状态,这时中断请求就无法被及时处理。为了解决这个问题,Java提供了一些方法来中断阻塞的线程:
  ·调用Thread.interrupt()方法:该方法会将当前线程的中断标记设置为true,同时中断正在等待的操作。
  · 调用java.util.concurrent.Future.cancel(boolean mayInterruptIfRunning)方法:该方法会尝试取消正在执行的任务,并中断阻塞的线程。
  下面是一个示例代码,演示如何中断阻塞的线程:
  class MyThread extends Thread {
      public void run() {
          while (!isInterrupted()) {
              try {
                  Thread.sleep(1000); // 等待1秒钟
              } catch (InterruptedException e) {
                  System.out.println("Thread interrupted");
                  interrupt(); // 重新设置中断标记
              }
          }
          System.out.println("Thread exit");
      }
  }
  public class Main {
      public static void main(String[] args) throws InterruptedException {
          MyThread thread = new MyThread();
          thread.start();
          Thread.sleep(3000); // 等待3秒钟
          thread.interrupt(); // 中断线程
          thread.join(); // 等待线程执行完毕
      }
  }
  在上面的示例代码中,我们创建了一个MyThread线程,并启动它。然后,等待该线程执行3秒钟后中断它。被中断线程在执行sleep()方法时,由于是阻塞操作,会抛出一个InterruptedException异常,并重新设置中断标记。
  (3)处理线程中断
  当一个线程被中断时,它需要决定如何响应中断请求。Java提供了两种方式处理线程中断:
  检查中断标记:如果线程检测到自身的中断标记被设置为true,那么它应该停止正在执行的操作并退出。
  抛出InterruptedException异常:当线程执行某些阻塞操作时,可能会抛出一个InterruptedException异常,表示线程被中断。此时,线程的中断标记会被清除,以便其他线程可以再次发起中断请求。
  下面是一个示例代码,演示如何处理线程中断:
  class MyThread extends Thread {
      public void run() {
          try {
              while (!isInterrupted()) { // 检查中断标记
                  System.out.println("Thread running...");
                  Thread.sleep(1000); // 等待1秒钟
              }
          } catch (InterruptedException e) {
              System.out.println("Thread interrupted"); // 抛出InterruptedException异常
          }
          System.out.println("Thread exit");
      }
  }
  public class Main {
      public static void main(String[] args) throws InterruptedException {
          MyThread thread = new MyThread();
          thread.start();
          Thread.sleep(3000); // 等待3秒钟
          thread.interrupt(); // 中断线程
          thread.join(); // 等待线程执行完毕
      }
  }
  在上面的示例代码中,我们创建了一个MyThread线程,并启动它。然后,等待该线程执行3秒钟后中断它。被中断线程会检查自身的中断标记,如果该标记被设置为true,那么线程就停止执行。
  3、进阶使用技巧
  除了基本的线程中断用法外,Java还提供了一些进阶使用技巧,帮助开发人员更好地掌握线程中断机制:
  (1)使用volatile关键字保证可见性
  当一个线程调用另一个线程的interrupt()方法时,实际上是将被中断线程的中断标志位设置为true。但是,这个标志位可能不会立即被被中断线程所感知,因为Java内存模型允许线程在自己的本地缓存中保存变量的值,而不及时刷新到主内存中。为了确保被中断线程能够及时感知中断请求,我们可以使用volatile关键字来修饰中断标志位,以保证可见性。
  下面是一个示例代码,演示如何使用volatile关键字保证中断标志位的可见性:
  class MyThread extends Thread {
      private volatile boolean isInterrupted = false;
      public void run() {
          while (!isInterrupted) { // 检查中断标记
              // 执行一些操作...
          }
          System.out.println("Thread interrupted");
      }
      public void interrupt() {
          isInterrupted = true; // 设置中断标记
          super.interrupt(); // 调用父类的中断方法
      }
  }
  public class Main {
      public static void main(String[] args) throws InterruptedException {
          MyThread thread = new MyThread();
          thread.start();
          Thread.sleep(1000); // 等待1秒钟
          thread.interrupt(); // 中断线程
          
          thread.join(); // 等待线程执行完毕
      }
  }
  在上面的示例代码中,我们将中断标志位设置为volatile类型,以保证其可见性。当线程被中断时,我们先更新中断标志位,然后调用父类的interrupt()方法,将中断请求传递给被中断线程。
  (2)使用Executor框架管理线程池
  Java中的Executor框架可以帮助我们管理线程池,使得多线程编程变得更加简单。当使用Executor框架时,我们可以通过设置ThreadPoolExecutor的中断策略来控制线程池中的线程如何响应中断请求。
  下面是一个示例代码,演示如何使用Executor框架管理线程池:
  class MyTask implements Runnable {
      public void run() {
          while (!Thread.currentThread().isInterrupted()) { // 检查中断标记
              // 执行一些操作...
          }
          System.out.println("Task interrupted");
      }
  }
  public class Main {
      public static void main(String[] args) throws InterruptedException {
          ExecutorService executor = Executors.newFixedThreadPool(10);
          for (int i = 0; i < 10; i++) {
              executor.execute(new MyTask());
          }
          Thread.sleep(1000); // 等待1秒钟
          executor.shutdownNow(); // 中断所有任务并关闭线程池
          
          executor.awaitTermination(10, TimeUnit.SECONDS); // 等待所有任务执行完毕
      }
  }
  在上面的示例代码中,我们创建了一个包含10个线程的固定大小线程池,并提交了10个MyTask任务。然后,等待1秒钟后中断所有任务并关闭线程池。注意,我们在使用shutdownNow()方法中断所有任务时,ThreadPoolExecutor会调用每个任务的interrupt()方法,以传递中断请求。
  (3)使用ReentrantLock和Condition实现可中断的锁
  在Java中,我们可以使用ReentrantLock和Condition来实现可中断的锁。具体来说,我们可以使用lockInterruptibly()方法获取锁,使用await()方法等待条件变量满足,并使用signal()方法通知其他线程条件已经发生改变。
  下面是一个示例代码,演示如何使用ReentrantLock和Condition实现可中断的锁:
  import java.util.concurrent.locks.Condition;
  import java.util.concurrent.locks.ReentrantLock;
  class MyThread extends Thread {
      private final ReentrantLock lock = new ReentrantLock();
      private final Condition condition = lock.newCondition();
      public void run() {
          try {
              lock.lockInterruptibly();
              while (!Thread.currentThread().isInterrupted()) { // 检查中断标记
                  System.out.println("Thread running...");
                  condition.await(); // 等待条件变量满足
              }
          } catch (InterruptedException e) {
              System.out.println("Thread interrupted"); // 抛出InterruptedException异常
          } finally {
              lock.unlock();
          }
          System.out.println("Thread exit");
      }
      public void signal() {
          lock.lock();
          try {
              condition.signal();
          } finally {
              lock.unlock();
          }
      }
  }
  public class Main {
      public static void main(String[] args) throws InterruptedException {
          MyThread thread = new MyThread();
          thread.start();
          Thread.sleep(1000); // 等待1秒钟
          thread.interrupt(); // 中断线程
          thread.join(); // 等待线程执行完毕
      }
  }
  在上面的示例代码中,我们创建了一个MyThread线程,并启动它。然后,等待该线程执行1秒钟后中断它。被中断线程使用lockInterruptibly()方法获取锁,并在等待条件变量满足时使用condition.await()方法阻塞线程。当线程被中断时,我们抛出一个InterruptedException异常,并在finally块中释放锁。
  另外,我们还实现了一个signal()方法,用于通知其他线程条件变量已经发生改变。需要注意的是,在调用signal()方法时,我们必须先获取锁,并在操作完成后释放锁。
  小结
  线程中断机制是Java多线程编程中的一个重要概念,可以帮助我们优雅地终止线程并释放资源。本文介绍了基本的线程中断用法,包括如何中断线程、如何处理线程中断以及如何使用volatile关键字、Executor框架和ReentrantLock实现更加高级的用法。

TAG: 软件开发 Java java

 

评分:0

我来说两句

Open Toolbar