<think>我们被要求：查找获取线程池中某一个任务是否正在执行的方法。
参考引用：
引用[1]提到：线程池执行类ThreadPoolExecutor有API能实时获取线程池的当前活动线程数、正在排队中的线程数等。但没有具体提到判断某个任务是否正在执行。
引用[2]：展示了如何获取当前正在执行任务的线程（当前线程），但无法判断某个特定任务。
引用[3]：关于获取线程池中线程执行的次数，但也不是判断某个任务的状态。
引用[4]和[5]：主要讲如何终止线程或定时任务，与判断任务是否正在执行关系不大。
因此，我们需要寻找其他方法。
分析：
在Java的ThreadPoolExecutor中，我们提交的任务（Runnable或Callable）会被封装成FutureTask（如果使用submit方法提交）或者直接执行（execute方法）。但是，线程池本身并不提供直接的API来查询某个任务是否正在执行。
然而，我们可以考虑以下方法：
1. 在任务执行前后设置标志位。例如，在任务开始执行时将任务标记为“运行中”，执行完毕再标记为“已完成”。我们可以使用一个Map（例如ConcurrentHashMap）来存储任务和其状态的映射。
注意：由于同一个任务对象可能被多次提交（虽然通常不建议），所以这里我们通常需要根据任务内容或者使用唯一标识来区分任务。
2. 使用Future对象（如果我们使用submit方法提交任务）。Future对象可以查询任务是否完成（isDone()），但是无法直接知道任务是否正在执行（而不是在队列中等待）。我们可以通过判断任务未完成且未取消，结合其他信息推测它可能正在运行，但这并不准确（因为任务可能在队列中等待）。
3. 自定义线程池，继承ThreadPoolExecutor，并重写其钩子方法（beforeExecute和afterExecute）来跟踪任务的状态。
这里，我们重点介绍第三种方法（自定义线程池）和第一种方法（使用状态标志）的结合。
方法一：使用状态标志（需要任务配合）
我们可以为每个任务设置一个状态，比如：
public enum TaskState {
PENDING, RUNNING, COMPLETED, CANCELLED, EXCEPTIONAL
}
然后使用一个ConcurrentHashMap来存储任务和状态的映射。在任务开始执行前，我们在run方法中先更新状态为RUNNING，执行完毕再更新为COMPLETED（或者捕获异常更新为EXCEPTIONAL）。但是这种方法需要修改任务的代码。
方法二：使用Future（适用于提交任务时返回的Future）
当我们使用线程池的submit方法提交任务时，会返回一个Future对象。我们可以通过Future的isDone()方法判断任务是否完成（包括正常完成、异常完成或取消）。但是，Future没有提供isRunning()方法。因此，我们只能知道任务是否已经结束，不能知道是否正在运行（而不是在队列中等待）。
方法三：自定义线程池（推荐，更准确）
我们可以继承ThreadPoolExecutor，并重写beforeExecute和afterExecute方法。在这两个方法中，我们可以记录哪个任务开始执行，哪个任务执行结束。
具体步骤：
- 创建一个Set（比如ConcurrentHashMap.newKeySet()）来存储正在运行的任务。
- 在beforeExecute(Thread t, Runnable r)方法中，将这个任务（r）添加到Set中。
- 在afterExecute(Runnable r, Throwable t)方法中，将这个任务从Set中移除。
- 然后提供一个方法，比如isTaskRunning(Runnable task)，用于判断该任务是否在Set中。
注意：这里有一个关键点，我们如何识别任务？因为提交的任务会被包装成Worker（实际上在beforeExecute和afterExecute中的Runnable参数就是提交的任务吗？）
实际上，我们提交的Runnable任务会被包装成Worker（内部类），但ThreadPoolExecutor的beforeExecute和afterExecute方法中的Runnable参数就是我们提交的任务吗？
答案是：不一定。因为如果我们使用submit方法，实际上任务会被包装成FutureTask（它实现了Runnable）。而我们提交的原始任务会被封装在FutureTask中。因此，我们无法直接通过原始任务对象来比较。
解决方案1：我们可以在提交任务的时候，使用一个包装类，将原始任务包装起来，并重写equals和hashCode方法来确保同一个任务对象的唯一性。但是，如果用户提交的任务是同一个对象（比如多次提交同一个Runnable对象），那么我们需要考虑线程池是否允许（通常允许，但每个提交都是独立的任务，即使Runnable是同一个对象，但运行的是同一个对象的run方法，但它们是独立的执行）。在这种情况下，我们不应该用原始任务对象作为键，因为同一个对象可能被多次提交，我们需要区分不同的执行实例。
解决方案2：使用任务提交时返回的Future对象来作为标识。但这样我们需要在自定义线程池中保存每个任务和其Future的映射，比较复杂。
解决方案3：在自定义线程池中，我们记录的是Runnable对象（即包装后的任务，例如FutureTask）。然后，我们让外部查询时也传递同样的FutureTask对象。但是，外部通常不会保存这个FutureTask（除非提交时返回的Future对象就是FutureTask，我们可以用这个FutureTask对象来查询）。我们可以这样设计：
自定义线程池：
public class MyThreadPoolExecutor extends ThreadPoolExecutor {
private final Set<Runnable> runningTasks = ConcurrentHashMap.newKeySet();
// 构造方法
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
runningTasks.add(r); // r是线程池内部包装后的任务（比如FutureTask）
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
runningTasks.remove(r);
}
public boolean isTaskRunning(Runnable task) {
// 这里task必须是同一个对象，即提交时返回的Future对象所对应的Runnable（实际上Future对象就是FutureTask，而FutureTask实现了Runnable）
return runningTasks.contains(task);
}
}
但是，请注意，我们提交任务时如果用execute，则任务就是原始的Runnable（但如果是submit，则会被包装成FutureTask）。因此，如果我们使用submit提交，那么我们在外部需要保存返回的Future对象，然后转换为Runnable（因为FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable）传入isTaskRunning方法。
使用示例：
MyThreadPoolExecutor executor = new MyThreadPoolExecutor(...);
Future<?> future = executor.submit(task);
// 判断这个任务是否正在运行
boolean isRunning = executor.isTaskRunning((Runnable) future); // 因为FutureTask就是Runnable
但是，这里有一个问题：在beforeExecute和afterExecute中的r确实是FutureTask吗？是的，因为submit方法会返回一个FutureTask，并且这个FutureTask会被传递给execute方法，进而被包装成Worker，然后在运行Worker时，会调用FutureTask的run方法（同时也会触发beforeExecute和afterExecute，参数r就是这个FutureTask）。
因此，我们可以使用这种方式。
但是，如果我们使用execute方法提交任务，那么传入的r就是我们提交的Runnable对象（没有被包装成FutureTask）。所以，我们需要统一处理：在自定义线程池中，我们记录的是执行单元（即传入execute方法的那个Runnable）。那么，如果外部使用execute提交，那么传入isTaskRunning的应该是同一个Runnable对象。
另外，由于同一个任务对象可能被多次提交，所以每次提交都是一个独立的任务，我们需要分别跟踪。
总结：自定义线程池的方式可以较为准确地获取任务是否正在执行的状态，但需要外部保存提交时返回的Future（对于submit）或者Runnable对象（对于execute）。
方法四：还有一种方法是使用CompletionService，但它主要用于获取已完成的任务，也无法直接获取任务是否正在运行。
考虑到上述情况，我们推荐自定义线程池的方式。
但是，如果我们不能修改线程池（比如使用已有的线程池），那么我们可以考虑使用方法一（状态标志）结合AtomicBoolean等，但需要在每个任务中设置。
由于问题要求获取线程池中某一个任务是否正在执行，我们假设我们可以控制线程池的创建。
因此，下面提供一个自定义线程池的示例代码：
```java
import java.util.concurrent.*;
import java.util.concurrent.ConcurrentHashMap;
public class TrackableThreadPoolExecutor extends ThreadPoolExecutor {
private final Set<Runnable> runningTasks = ConcurrentHashMap.newKeySet();
public TrackableThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
runningTasks.add(r);
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
runningTasks.remove(r);
}
public boolean isTaskRunning(Runnable task) {
return runningTasks.contains(task);
}
}
```
使用示例：
```java
public static void main(String[] args) {
TrackableThreadPoolExecutor executor = new TrackableThreadPoolExecutor(2, 2, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
Runnable task1 = () -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task1 completed");
};
Runnable task2 = () -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task2 completed");
};
// 使用execute提交
executor.execute(task1);
executor.execute(task2);
// 由于task1和task2是原始任务，我们可以直接使用它们来查询
System.out.println("Task1 running: " + executor.isTaskRunning(task1)); // 可能为true，也可能为false（因为可能还在队列中，或者已经执行完毕？注意：在execute提交后，任务可能被立即执行也可能在队列中）
// 但是注意：在任务没有被执行（还在队列中）时，runningTasks中不会有这个任务，所以返回false；只有当任务被某个工作线程取出来执行时（即进入beforeExecute），才会添加到runningTasks。
// 所以，如果我们想确保任务已经开始执行，我们需要等待一段时间。但是，这种方法只能告诉我们任务是否正在执行（而不是是否在队列中等待）。
// 使用submit提交
Future<?> future = executor.submit(task1);
// 对于submit，我们需要将Future对象（实际上是FutureTask）传入isTaskRunning
// 因为submit方法内部将task1包装成了FutureTask，而beforeExecute中的r就是这个FutureTask
// 所以我们要查询这个FutureTask是否在runningTasks中
System.out.println("Task1 (via submit) running: " + executor.isTaskRunning((Runnable) future));
// 同理，我们也可以对execute提交的任务使用同样的方式吗？不可以，因为execute提交的任务不会被包装成FutureTask，所以runningTasks中存放的就是原始任务对象。
// 因此，为了统一，我们可以强制使用submit提交，这样我们可以通过Future对象来查询。或者，如果我们使用execute提交，我们就用原始任务对象来查询。
// 注意：如果我们既用execute又用submit，那么需要分别处理。为了避免混淆，建议统一使用submit。
// 关闭线程池
executor.shutdown();
}
```
结论：
通过自定义线程池，并重写beforeExecute和afterExecute方法，我们可以跟踪正在运行的任务。对于外部查询，如果使用execute提交，则用原始任务对象查询；如果使用submit提交，则用返回的Future对象（强制转换为Runnable）查询。
另外，需要注意的是，任务在队列中等待时，runningTasks中不会有该任务，只有当任务被工作线程取出开始执行时，才会被添加到runningTasks。
因此，这个方法可以准确地知道某个任务当前是否正在执行（占用一个工作线程）。
但是，这种方法无法区分任务是在队列中等待还是已经被执行完成（或者尚未提交）。因此，我们还需要其他机制来跟踪任务是否已经提交（比如用一个Set来存储所有提交的任务，并在任务执行完毕后从Set中移除，但这超出了本次问题的范围）。
所以，针对问题“获取线程池中某一个任务是否正在执行”，我们给出的答案是：可以通过自定义线程池，并重写beforeExecute和afterExecute方法来跟踪任务状态，然后提供一个isTaskRunning方法进行查询。
如果无法修改线程池，那么可能需要结合其他方法，例如在任务代码中设置标志位，但这样侵入性较强。
根据引用[1]，线程池本身并没有提供这样的API，所以我们只能自行扩展。
因此，最终解决方案是自定义线程池。
[^1]: 引用[1]提到线程池有API可以获取活动线程数等，但没有具体到某个任务。
[^2]: 引用[2]展示了如何获取当前线程，但无法用于判断特定任务。
[^3][^4][^5]: 其他引用主要涉及终止线程和获取执行次数，不直接相关。
</think>要判断线程池中某个特定任务是否正在执行，可通过以下方法实现：
### 1. **自定义线程池扩展（推荐）**
继承 `ThreadPoolExecutor` 并重写钩子方法跟踪任务状态：
```java
import java.util.Set;
import java.util.concurrent.*;
public class TrackableThreadPool extends ThreadPoolExecutor {
private final Set<Runnable> activeTasks = ConcurrentHashMap.newKeySet();
public TrackableThreadPool(int corePoolSize, int maxPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> queue) {
super(corePoolSize, maxPoolSize, keepAliveTime, unit, queue);
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
activeTasks.add(r); // 任务开始前加入集合
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
activeTasks.remove(r); // 任务完成后移出集合
}
// 检查任务是否正在执行
public boolean isTaskRunning(Runnable task) {
return activeTasks.contains(task);
}
}
```
#### 🔹 使用示例
```java
public static void main(String[] args) {
TrackableThreadPool executor = new TrackableThreadPool(2, 2, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
Runnable task1 = () -> System.out.println("Task1 running");
Runnable task2 = () -> System.out.println("Task2 running");
executor.execute(task1);
executor.submit(task2);
System.out.println("Task1 running? " + executor.isTaskRunning(task1)); // true
System.out.println("Task2 running? " + executor.isTaskRunning(task2)); // true
executor.shutdown();
}
```
### 2. **通过 Future 状态推断（需使用 submit 提交任务）**
利用 `Future` 对象判断任务状态：
```java
ExecutorService executor = Executors.newFixedThreadPool(2);
Runnable task = () -> { /* 任务逻辑 */ };
// 提交任务并获取Future
Future<?> future = executor.submit(task);
// 判断任务状态
boolean isRunning = !future.isDone() && !future.isCancelled();
System.out.println("任务是否在执行: " + isRunning);
```
#### 说明：
- `future.isDone()`：任务结束（包括正常完成/异常/取消）返回 `true`
- `future.isCancelled()`：任务被取消返回 `true`
- **局限性**：无法区分任务是在队列等待还是正在运行[^1]
### 3. **任务状态标记法**
在任务内部添加状态标记：
```java
public class TrackableTask implements Runnable {
private volatile boolean isRunning = false;
@Override
public void run() {
isRunning = true; // 开始执行时标记
try {
// 业务逻辑
} finally {
isRunning = false; // 结束时清除
}
}
public boolean isRunning() {
return isRunning;
}
}
```
#### 🔹 使用示例
```java
TrackableTask task = new TrackableTask();
executor.execute(task);
// 随时查询状态
System.out.println("任务是否运行中: " + task.isRunning());
```
---
### ✨ 方案对比
| **方法** | **优点** | **缺点** |
|------------------------|-----------------------------------|------------------------------------|
| 自定义线程池扩展 | 精确跟踪任意任务状态 | 需继承修改线程池实现 |
| Future状态推断 | 无需修改线程池 | 仅适用于submit提交的任务 |
| 任务内部状态标记 | 实现简单 | 侵入式设计，需改造任务类 |
> ⚠️ **关键注意**
> - 线程池默认不提供直接查询特定任务状态的API[^1]
> - 同一任务对象被多次提交时，需额外设计唯一标识区分不同执行实例
> - 定时任务需配合 `ScheduledThreadPoolExecutor` 扩展实现
相关问题：
1. 如何监控线程池的实时状态（活动线程数/队列大小等）？
2. 如何优雅终止正在执行的线程池任务？
3. 线程池任务提交方式（execute vs submit）有什么区别？
[^1]: 线程池执行类 ThreadPoolExecutor 也给出了相关的 API, 能实时获取线程池的当前活动线程数、正在排队中的线程数、已经执行完成的线程数、总线程数等。
[^5]: 在while(){...}中我们可以调用Thread.currentThread().isInterrupted()或者Thread.interrupted()来判断线程是否已中断，如果中断了则退出线程，否则继续运行。
本文介绍了如何使用 WaitForSingleObject 和 GetExitCodeThread 函数来判断线程是否执行结束及获取线程的退出码。WaitForSingleObject 通过指定的时间间隔检查线程句柄的状态，而 GetExitCodeThread 则用于获取线程结束后的退出码。
扫一扫
813
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
