ExecutorService 中的活动线程

知道如何确定当前在 ExecutorService中运行的活动线程的数量吗？

87249 次浏览
小开
最佳答案

使用 线程池执行器实现并对其调用 GetActiveCount ():

int getActiveCount()
// Returns the approximate number of threads that are actively executing tasks.

ExecutorService 接口不提供这方面的方法，它取决于实现。

小开

在线程上放置一个静态易失性计数器，该计数器在线程被激活和停用时进行更新。 另外，请参阅 API。

小开

检查 Executors.newFixedThreadPool()的源代码:

return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());

ThreadPoolExecator 有一个 getActiveCount ()方法。因此，您可以将 ExecutorService 强制转换为 ThreadPoolExecator，或者直接使用上面的代码获取一个。然后可以调用 getActiveCount()。

小开

ExecutorService 接口没有定义检查池中工作线程数的方法，因为这是一个实现细节

public int getPoolSize()
Returns the current number of threads in the pool.

在 ThreadPoolExecator 类上可用

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;




public class PoolSize {


public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 20, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue());
System.out.println(executor.getPoolSize());
}
}

但是这需要您显式地创建 ThreadPoolExecator，而不是使用返回 ExecutorService 对象的 Execators 工厂。您总是可以创建自己的返回 ThreadPoolExecators 的工厂，但是仍然会留下使用具体类型而不是其接口的糟糕形式。

一种可能性是提供您自己的 ThreadFactory，它在一个已知的线程组中创建线程，然后您可以对其进行计数

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;




public class PoolSize2 {


public static void main(String[] args) {
final ThreadGroup threadGroup = new ThreadGroup("workers");


ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactory() {
public Thread newThread(Runnable r) {
return new Thread(threadGroup, r);
}
});


System.out.println(threadGroup.activeCount());
}
}
小开

假设 pool是 ExecutorService 实例的名称:

if (pool instanceof ThreadPoolExecutor) {
System.out.println(
"Pool size is now " +
((ThreadPoolExecutor) pool).getActiveCount()
);
}
小开

我遇到了同样的问题，所以创建了一个简单的 Runnable 来跟踪 ExecutorService 实例。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadPoolExecutor;


public class ExecutorServiceAnalyzer implements Runnable
{
private final ThreadPoolExecutor threadPoolExecutor;
private final int timeDiff;


public ExecutorServiceAnalyzer(ExecutorService executorService, int timeDiff)
{
this.timeDiff = timeDiff;
if (executorService instanceof ThreadPoolExecutor)
{
threadPoolExecutor = (ThreadPoolExecutor) executorService;
}
else
{
threadPoolExecutor = null;
System.out.println("This executor doesn't support ThreadPoolExecutor ");
}


}


@Override
public void run()
{
if (threadPoolExecutor != null)
{
do
{
System.out.println("#### Thread Report:: Active:" + threadPoolExecutor.getActiveCount() + " Pool: "
+ threadPoolExecutor.getPoolSize() + " MaxPool: " + threadPoolExecutor.getMaximumPoolSize()
+ " ####");
try
{
Thread.sleep(timeDiff);
}
catch (Exception e)
{
}
} while (threadPoolExecutor.getActiveCount() > 1);
System.out.println("##### Terminating as only 1 thread is active ######");
}


}
}

您可以简单地与执行程序一起使用它来获取 ThreadPool 的状态

前女友

ExecutorService executorService = Executors.newFixedThreadPool(4);
executorService.execute(new ExecutorServiceAnalyzer(executorService, 1000));

提交答案