Java多线程编程中，如何优雅地终止线程？

Java线程中断（Interrupt）是Java语言的一个重要特性，它允许一个线程在另一个线程运行时发出信号，告诉该线程停止正在执行的操作。本篇博客将深入探讨Java线程中断的相关知识点，包括线程中断的基本原理、如何使用线程中断、如何处理线程中断等方面。

创新互联-专业网站定制、快速模板网站建设、高性价比民乐网站开发、企业建站全套包干低至880元,成熟完善的模板库,直接使用。一站式民乐网站制作公司更省心,省钱,快速模板网站建设找我们，业务覆盖民乐地区。费用合理售后完善，十载实体公司更值得信赖。

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实现更加高级的用法。

文章标题：Java多线程编程中，如何优雅地终止线程？
文章源于：http://www.shufengxianlan.com/qtweb/news10/213910.html

成都网站建设公司_创新互联，为您提供微信小程序、外贸建站、响应式网站、企业网站制作、定制网站、面包屑导航

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

行业网站建设

成都广告公司　　 　成都成品网站　　 　成都品牌官网设计公司　　 　成都网页设计　　 　化妆品企业网站建设方案　　 　雅安做网站　　 　成都网站安全运维　　 　顺泽窗帘　　 　企业画册设计制作　　 　外贸营销网站建设　　 　微信服务号订阅号开发　　 　全网整合营销　　 　消防维保　　 　成都ssl证书认证　　 　不锈钢防护栏　　 　网站排名优化　　 　网络推广公司　　 　棕树数据中心　　 　成都租用服务器　　 　铁科精智测控