java 关闭一个正在执行的线程

最新推荐文章于 2025-06-13 13:35:43 发布
转载 最新推荐文章于 2025-06-13 13:35:43 发布 · 2.1w 阅读 · 4

本文详细介绍了Java中线程中断的几种方式，并提供了具体的代码示例。包括如何使用Thread类的interrupt方法、设置标志量以及结合I/O操作来中断线程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

中断（Interrupt）一个线程意味着在该线程完成任务之前停止其正在进行的一切，有效地中止其当前的操作。线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序。虽然初次看来它可能显得简单，但是，你必须进行一些预警以实现期望的结果。你最好还是牢记以下的几点告诫。

首先，忘掉Thread.stop方法。虽然它确实停止了一个正在运行的线程，然而，这种方法是不安全也是不受提倡的，这意味着，在未来的JAVA版本中，它将不复存在。

1：

 
  1. public static void main(String[] args) throws Exception {  
  2.         MyThread mt = new MyThread();  
  3.         Thread t = new Thread(mt);  
  4.         System.out.println("System is ready to start thread");  
  5.         t.start();  
  6.           
  7.         Thread.sleep(3000);  
  8.           
  9.         System.out.println("System is ready to stop thread");  
  10.         //线程没有处于阻塞状态，调用线程对应的interrupt()不能让运行的线程停止下来  
  11.         t.interrupt();  
  12.     }  
  13.       
  14.     static class MyThread implements Runnable {  
  15.           
  16.         public volatile boolean stop = false;  
  17.           
  18.         private void dosomethig() throws InterruptedException {  
  19.             long time = System.currentTimeMillis();  
  20.             while(System.currentTimeMillis() - time < 1000) {  
  21.                   
  22.             }  
  23.             System.out.println("all things had been done!!");  
  24.         }  
  25.           
  26.         @Override 
  27.         public void run() {  
  28.             try {  
  29.                 while(!stop) {  
  30.                     System.out.println(Thread.currentThread().getName() + " is running..");  
  31.                     dosomethig();  
  32.                 }  
  33.             } catch (InterruptedException e) {  
  34.                 e.printStackTrace();  
  35.             } finally {  
  36.                 System.out.println(Thread.currentThread().getName() + " is exiting under request.");  
  37.             }  
  38.         }  
  39.     } 
 
  1. 运行结果：  
  2. System is ready to start thread  
  3. Thread-0 is running..  
  4. all things had been done!!  
  5. Thread-0 is running..  
  6. all things had been done!!  
  7. Thread-0 is running..  
  8. all things had been done!!  
  9. Thread-0 is running..  
  10. System is ready to stop thread  
  11. all things had been done!!  
  12. Thread-0 is running..  
  13. all things had been done!!  
  14. Thread-0 is running..  
  15. all things had been done!!  
  16. Thread-0 is running..  
  17. all things had been done!!  
  18. Thread-0 is running..  

 

 

2：

 
  1. public static void main(String[] args) throws Exception {  
  2.         MyThread mt = new MyThread();  
  3.         Thread t = new Thread(mt);  
  4.         System.out.println("System is ready to start thread");  
  5.         t.start();  
  6.           
  7.         Thread.sleep(3000);  
  8.           
  9.         System.out.println("System is ready to stop thread");  
  10. //      t.interrupt();  
  11.         //当线程没有处于阻塞状态，通过改变标志量，可以让线程停止运行  
  12.         mt.stop = true;  
  13.     } 
 
  1. 运行结果：  
  2. System is ready to start thread  
  3. Thread-0 is running..  
  4. all things had been done!!  
  5. Thread-0 is running..  
  6. all things had been done!!  
  7. Thread-0 is running..  
  8. System is ready to stop thread  
  9. all things had been done!!  
  10. Thread-0 is exiting under request. 

 

3：

 
  1. public static void main(String[] args) throws Exception {  
  2.         MyThread mt = new MyThread();  
  3.         Thread t = new Thread(mt);  
  4.         System.out.println("System is ready to start thread");  
  5.         t.start();  
  6.           
  7.         Thread.sleep(3000);  
  8.           
  9.         System.out.println("System is ready to stop thread");  
  10. //      t.interrupt();  
  11.         //此时线程一直处于阻塞状态，无法检查标志量，所以仅通过改变标志量无法停止线程  
  12.         mt.stop = true;  
  13.     }  
  14.       
  15.     static class MyThread implements Runnable {  
  16.           
  17.         public volatile boolean stop = false;  
  18.           
  19.         private void dosomethig() throws InterruptedException {  
  20. //          long time = System.currentTimeMillis();  
  21. //          while(System.currentTimeMillis() - time < 1000) {  
  22. //                
  23. //          }  
  24.             Thread.currentThread().join();  
  25.             System.out.println("all things had been done!!");  
  26.         }  
  27.           
  28.         @Override 
  29.         public void run() {  
  30.             try {  
  31.                 while(!stop) {  
  32.                     System.out.println(Thread.currentThread().getName() + " is running..");  
  33.                     dosomethig();  
  34.                 }  
  35.             } catch (InterruptedException e) {  
  36.                 e.printStackTrace();  
  37.             } finally {  
  38.                 System.out.println(Thread.currentThread().getName() + " is exiting under request.");  
  39.             }  
  40.         }  
  41.     } 
 
  1. 运行结果：  
  2. System is ready to start thread  
  3. Thread-0 is running..  
  4. System is ready to stop thread  

4：

 
  1. public static void main(String[] args) throws Exception {  
  2.         MyThread mt = new MyThread();  
  3.         Thread t = new Thread(mt);  
  4.         System.out.println("System is ready to start thread");  
  5.         t.start();  
  6.           
  7.         Thread.sleep(3000);  
  8.           
  9.         System.out.println("System is ready to stop thread");  
  10.         //通过调用线程对象上的interrupt() 正在运行的线程对象会接收到一个InterruptedException异常，从而停止运行  
  11.                   t.interrupt();  
  12. //      mt.stop = true;  
  13.     } 
 
  1. 运行结果:  
  2. System is ready to start thread  
  3. Thread-0 is running..  
  4. System is ready to stop thread  
  5. java.lang.InterruptedException  
  6. Thread-0 is exiting under request.  
  7.     at java.lang.Object.wait(Native Method)  
  8.     at java.lang.Thread.join(Thread.java:1143)  
  9.     at java.lang.Thread.join(Thread.java:1196)  
  10.     at com.thread.DeadLockTest$MyThread.dosomethig(DeadLockTest.java:29)  
  11.     at com.thread.DeadLockTest$MyThread.run(DeadLockTest.java:38)  
  12.     at java.lang.Thread.run(Thread.java:619) 

 

5：中断I/O操作

 
  1. public static void main(String[] args) throws Exception {  
  2.         MyThread mt = new MyThread();  
  3.         Thread t = new Thread(mt);  
  4.         System.out.println("System is ready to start thread");  
  5.         t.start();  
  6.           
  7.         Thread.sleep(3000);  
  8.           
  9.         System.out.println("System is ready to stop thread");  
  10.         t.interrupt();  
  11.         mt.stop = true;  
  12.         mt.socket.close();  
  13.     }  
  14.       
  15.     static class MyThread implements Runnable {  
  16.         public volatile boolean stop = false;  
  17.         ServerSocket socket = null;  
  18.           
  19.         private void dosomethig() throws InterruptedException, IOException {  
  20. //          long time = System.currentTimeMillis();  
  21. //          while(System.currentTimeMillis() - time < 1000) {  
  22. //                
  23. //          }  
  24. //          Thread.currentThread().join();  
  25.             socket = new ServerSocket(9999);  
  26.             //这里需要调用Socket对应的close方法 这样子 被阻塞的线程会接收到一个SocketException 从而停止运行  
  27.             socket.accept();  
  28.             System.out.println("all things had been done!!");  
  29.         }  
  30.           
  31.         @Override 
  32.         public void run() {  
  33.             try {  
  34.                 while(!stop) {  
  35.                     System.out.println(Thread.currentThread().getName() + " is running..");  
  36.                     dosomethig();  
  37.                 }  
  38.             } catch (InterruptedException e) {  
  39.                 e.printStackTrace();  
  40.             } catch (IOException e) {  
  41.                 e.printStackTrace();  
  42.             } finally {  
  43.                 System.out.println(Thread.currentThread().getName() + " is exiting under request.");  
  44.             }  
  45.         }  
  46.     } 
 
  1. 运行结果：  
  2. System is ready to start thread  
  3. Thread-0 is running..  
  4. System is ready to stop thread  
  5. java.net.SocketException: socket closed  
  6. Thread-0 is exiting under request.  
  7.     at java.net.PlainSocketImpl.socketAccept(Native Method)  
  8.     at java.net.PlainSocketImpl.accept(PlainSocketImpl.java:384)  
  9.     at java.net.ServerSocket.implAccept(ServerSocket.java:453)  
  10.     at java.net.ServerSocket.accept(ServerSocket.java:421)  
  11.     at com.thread.DeadLockTest$MyThread.dosomethig(DeadLockTest.java:33)  
  12.     at com.thread.DeadLockTest$MyThread.run(DeadLockTest.java:42)  
  13.     at java.lang.Thread.run(Thread.java:619)  

 http://www.blogjava.net/jinfeng_wang/archive/2008/04/27/196477.html

如何停止一个正在运行的线程?
Tyshawn的博客
04-16 1236
如何停止一个正在运行的线程? 这个一个面试常问的问题, 我们有两种办法, 分别是stop()和interrupt(), 但stop()太过于暴力, 无法保证线程业务的原子性, 且已过期, 不推荐使用. 使用stop()来停止线程 stop()方法让线程立即停止运行, 这种暴力停止可能会破坏线程业务的原子性, 如下所示: static class MyThread extends Thread { ...
Java 中如何终止一个正在运行的线程
smart_an的专栏
01-24 947
作者简介：大家好，我是码炫码哥，前中兴通讯、美团架构师，现任某互联网公司CTO，兼职码炫课堂主讲源码系列专题代表作：《jdk源码&多线程&高并发》，《深入tomcat源码解析》，《深入netty源码解析》，《深入dubbo源码解析》，《深入springboot源码解析》，《深入spring源码解析》，《深入redis源码解析》等联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬。
Spring Bean生命周期
weixin_44289947的博客
06-13 1491
Spring框架的核心能力之一是Bean的生命周期管理。通过容器对Bean的创建、初始化、使用到销毁的全生命周期进行管控，可以专注于业务逻辑，而无需手动处理对象的创建与资源释放。
Java多线程详解二 如何停止一个正在运行的线程
Zsiyuan的博客
05-28 1219
1.使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。 2.使用stop方法强行终止，但是不推荐这个方法，因为stop和suspend及resume一样都是过期作废的方法。 3.使用interrupt方法中断线程 class MyThread extends Thread { volatile boolean stop = false; public void run() { while (!stop) { System.out.println(getName() +
Java 终止线程的几种方式
书香水墨
04-06 9306
一般run()方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。他们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。我们可以直接使用thread.stop()来强行终止线程，但是stop()方法是很危险的，就想突然关闭电源一样。所谓正常运行结束，就是程序正常运行结束，线程自动结束。
Java多线程--等待所有子线程执行完的五种方法.docx
09-14
`CountDownLatch`是Java并发包(`java.util.concurrent`)中的一个工具类，它允许一个或多个线程等待其他线程完成操作。创建一个计数器为N的`CountDownLatch`，每当一个线程完成其任务时，都会调用`countDown()`，...
java编写的一个多线程程序，模拟银行排队.zip
01-01
2. **同步机制**：在银行排队系统中，必须确保同一时间只有一个客户正在被服务，这就需要使用到线程同步。Java提供了多种同步机制，如`synchronized`关键字、`wait()`, `notify()`, `notifyAll()`方法以及`Lock`接口...
详解Java利用ExecutorService实现同步执行大量线程
08-31
ExecutorService是java.util.concurrent包下Executor接口的一个实现，它提供了一种创建线程池的方式，可以有效地管理和调度线程。在Java 1.5及后续版本中引入，ExecutorService使得开发者能够创建不同类型的线程池，...
Java中停止线程执行的方法
08-04
在Java编程中，控制线程的执行是多线程编程中的关键部分。本文将深入探讨如何在Java中正确地暂停或停止线程，以及为何不推荐使用wait()和notify()来实现这一目标。 首先，我们要了解Java中线程的生命周期，包括新建...
Java如何中断一个正在运行的线程
08-10
绍Java如何中断一个正在运行的线程
如何停止一个正在运行的线程
z_ssyy的博客
12-29 2265
来判断thread对象所代表的线程是否停止，但从控制台打印的结果来看，线程并未停止，这也证明了interrupted()方法的解释，测试当前线程是否已经中断。我们先来看看this.interrupted()方法的解释：测试当前线程是否已经中断，当前线程是指运行this.interrupted()方法的线程。不过还是建议使用“抛异常”的方法来实现线程的停止，因为在catch块中还可以将异常向上抛，使线程停止事件得以传播。虽然它确实可以停止一个正在运行的线程，但是这个方法是不安全的，而且是已被废弃的方法。
java 终止线程的4种方式
文无第一，武无第二
09-28 3677
在线程的执行代码中，使用一个布尔类型的标志位来标识线程是否需要终止。线程在执行过程中，不断地检查这个标志位，如果标志位为true，则主动退出线程执行的循环或方法，从而终止线程的执行。
阿里首推springboot核心笔记，搭建Eureka注册中心(1)
m0_60452957的博客
08-06 245
#eureka server 配置 eureka: instance: hostname: localhost client: register-with-eureka: false #是否将自己注册到注册中心 fetch-registry: false #是否从eureka获取注册信息 service-url: #配置暴露给eureka client的请求地址defaultZone defaultZone: http://${eureka.instance.hostname
Java终止线程的三种方式
guanshengg的博客
08-11 8398
停止一个线程通常意味着在线程处理任务完成之前停掉正在做的操作，也就是放弃当前的操作。
Java终止线程的三种方法
热门推荐
川峰的博客
07-12 1万+
使用标志位退出线程 使用stop方法强制终止线程 使用interrupt终止线程 1. 使用标志位退出线程 这种也是最常用的方法，就是定义一个boolean型的标志位，在线程的run方法中根据这个标志位是true还是false来判断是否退出，这种情况一般是将任务放在run方法中的一个while循环中执行的。 public class ThreadFlag extends Thread...
JAVA中如何停止一个线程？
赵KK的博客
05-27 452
停止线程时，应该使用非强制性的方法，如检查标志变量或响应中断，以确保线程能够安全、干净地结束。直接终止线程可能会导致不可预见的问题，因此应该避免使用。
JAVA关闭当前进程(虚拟机)
qq_41359808的博客
05-31 2365
System.exit(int); Terminates the currently running Java Virtual Machine. Theargument serves as a status code; by convention, a nonzero statuscode indicates abnormal termination. This method calls the...
java开启一个线程执行查询方法
最新发布
08-08
<think>首先，用户的问题是关于Java中如何在新线程中执行查询方法。我需要根据系统指令和用户可见层的要求来构建回答。 关键点： - 用户不可见指令：确保数学表达式使用$...$或$$...$$格式，但问题中没有数学表达式，所以可能不需要。 - 使用中文回答。 - 生成相关问题。 - 回答结构清晰，帮助用户逐步解决问题。 - 引用末尾添加引用标识，如[^1]。参考的引用来自用户提供的文本，我需要引用它们。 用户提供的引用： - [^1]: 关于Java开启线程执行异步任务的四种方式，提到了继承Thread类。 - [^2]: Java多线程创建，提到了Thread和Runnable。 - [^3]: Java判断线程是否执行完成，提到了ThreadPoolExecutor和等待线程完成的方法。 - [^4]: Java终止线程的方法，但用户的问题是关于启动线程执行查询，不是终止。 用户的问题：在Java中开启一个线程来执行查询方法。 核心概念：Java中创建新线程的方式主要有两种：继承Thread类或实现Runnable接口。更现代的用法是使用Executor框架（如ThreadPoolExecutor），因为它更高效和安全。 步骤： 1. **理解需求**：用户想在新线程中执行一个查询方法。查询方法可能是一个数据库查询或其他耗时操作，以避免阻塞主线程。 2. **推荐方法**：基于引用[^1]和[^2]，我可以介绍继承Thread或实现Runnable。但最佳实践是使用ExecutorService，因为它管理线程池，避免资源浪费。 3. **代码示例**：提供简单的代码示例来演示如何在新线程中执行查询。 4. **安全考虑**：提到线程安全和资源管理，如引用[^3]中提到的等待线程完成的问题。 5. **结构回答**： - 介绍基本方法。 - 提供代码示例。 - 讨论优化和注意事项。 - 生成相关问题。 回答结构： - 开头解释为什么需要在新线程中执行查询（例如，避免UI冻结或提高响应性）。 - 描述Java中创建线程的常见方式： - 方式1：继承Thread类（基于引用[^1]）。 - 方式2：实现Runnable接口（基于引用[^2]）。 - 方式3：使用ExecutorService（推荐，因为它更现代）。 - 为每种方式提供简单代码示例。 - 针对查询方法，给出具体示例。 - 结束时生成相关问题。 引用处理： - 在回答中引用相关部分，例如： - 当提到继承Thread时，引用[^1]。 - 当提到Runnable时，引用[^2]。 - 当提到等待线程完成时，引用[^3]。 代码示例： - 假设查询方法是一个简单的模拟，如queryDatabase()。 - 使用Runnable的示例，因为它更灵活。 - 使用ExecutorService的示例。 生成相关问题： - 基于主题，如线程安全、性能优化等。 最终回答大纲： 1. 介绍：解释在新线程中执行查询的好处。 2. 方法1：使用Thread类。 3. 方法2：使用Runnable接口。 4. 方法3：使用ExecutorService（推荐）。 5. 注意事项：如线程安全、等待完成（引用[^3]）。 6. 相关问题。</think>### 在Java中开启新线程执行查询方法 在Java中，开启新线程执行查询方法（如数据库查询或耗时操作）可以避免阻塞主线程，提高程序响应性和性能[^2]。Java提供了多种方式实现线程创建，核心是通过`Thread`类、`Runnable`接口或更现代的`ExecutorService`框架。以下是逐步指南，基于最佳实践和引用内容，我将提供代码示例和关键注意事项。 #### 步骤1: 定义查询方法 首先，创建一个查询方法（例如，模拟数据库查询）。这个方法将在新线程中执行。 ```java public class QueryService { // 示例查询方法：模拟耗时操作 public String executeQuery() { try { Thread.sleep(2000); // 模拟查询耗时2秒 return "查询结果: 数据加载成功"; } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 处理中断 return "查询失败"; } } } ``` #### 步骤2: 开启新线程执行查询 Java中创建新线程的主要方式有三种。选择哪种取决于需求（如是否需要返回值、线程管理复杂度等）。 **方式1: 继承`Thread`类（简单直接，适合简单任务）** 基于引用[^1]，通过重写`run()`方法定义线程任务。 ```java public class QueryThread extends Thread { private String result; @Override public void run() { QueryService service = new QueryService(); result = service.executeQuery(); // 在新线程中执行查询 System.out.println("线程ID: " + getId() + ", " + result); } public String getResult() { return result; } public static void main(String[] args) { QueryThread thread = new QueryThread(); thread.start(); // 启动新线程 // 主线程继续执行其他任务 System.out.println("主线程继续运行..."); } } ``` - **优点**：简单易用，直接调用`start()`启动线程。 - **缺点**：Java不支持多继承，扩展性差；无法直接获取返回值（需通过字段共享）。 - **适用场景**：快速测试或简单异步任务[^1]。 **方式2: 实现`Runnable`接口（推荐，更灵活）** 基于引用[^2]，通过`Runnable`定义任务，然后传递给`Thread`对象。 ```java public class QueryRunnable implements Runnable { private String result; @Override public void run() { QueryService service = new QueryService(); result = service.executeQuery(); System.out.println("线程ID: " + Thread.currentThread().getId() + ", " + result); } public String getResult() { return result; } public static void main(String[] args) { QueryRunnable task = new QueryRunnable(); Thread thread = new Thread(task); thread.start(); // 启动新线程执行查询 System.out.println("主线程继续运行..."); } } ``` - **优点**：避免单继承限制；任务与线程分离，代码复用性高。 - **缺点**：同样需通过字段共享返回值。 - **适用场景**：大多数异步任务，尤其在需要任务复用时[^2]。 **方式3: 使用`ExecutorService`（推荐，高效管理线程池）** 对于查询方法，推荐使用`ExecutorService`（如`ThreadPoolExecutor`），因为它管理线程生命周期，避免资源浪费。基于引用[^3]，可以结合`Future`获取返回值。 ```java import java.util.concurrent.*; public class QueryExecutor { public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); // 创建线程池 QueryService service = new QueryService(); // 提交查询任务，返回Future对象以获取结果 Future<String> future = executor.submit(() -> { return service.executeQuery(); // Lambda表达式定义任务 }); System.out.println("主线程继续运行..."); // 等待查询完成并获取结果（可选，避免主线程阻塞） String result = future.get(); // 阻塞直到线程完成 System.out.println("查询结果: " + result); executor.shutdown(); // 关闭线程池[^3] } } ``` - **优点**：自动管理线程池，支持返回值（通过`Future`）；避免手动创建线程的开销。 - **缺点**：需处理`InterruptedException`和`ExecutionException`。 - **适用场景**：生产环境中的高并发查询，如Web应用中的异步数据处理[^3]。 #### 关键注意事项 1. **线程安全**：如果查询方法涉及共享资源（如数据库连接），需添加同步机制（如`synchronized`块）以防止数据竞争[^2]。 2. **等待线程完成**：如果主线程需等待查询结果，使用`future.get()`（方式3）或循环检查标志（方式1/2）。但避免忙等待，推荐`Future`或`CountDownLatch`[^3]。 3. **资源管理**：使用`ExecutorService`后必须调用`shutdown()`释放资源；否则可能导致内存泄漏。 4. **异常处理**：在`run()`方法中捕获异常，防止线程意外终止[^4]。 5. **性能考量**：对于频繁查询，使用线程池（如`Executors.newFixedThreadPool(5)`）限制线程数量，避免资源耗尽。 #### 总结 - 简单任务：用`Thread`或`Runnable`。 - 生产级应用：优先选`ExecutorService`，支持返回值和线程池管理。 - 示例中，`executeQuery()`代表您的查询逻辑，替换为实际代码即可。 通过以上方法，您可以高效地在Java新线程中执行查询操作，提升程序并发性能。如果查询涉及复杂逻辑（如数据库连接），确保在方法内处理资源打开/关闭。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值