it-swarm.cn

ExecutorService中的活动线程

任何想法如何确定当前在 ExecutorService中运行的活动线程数

56
zanussi

使用 ThreadPoolExecutor implementation并调用 getActiveCount() 对它:

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

ExecutorService接口没有提供相应的方法,它取决于实现。

63
Daan

假设pool是ExecutorService实例的名称:

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

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

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

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

21
Arno

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

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

可以在ThreadPoolExecutor类中使用

 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()); 
} 
} 

但这需要您显式创建ThreadPoolExecutor,而不是使用返回ExecutorService对象的Executors工厂。你总是可以创建自己的工厂来返回ThreadPoolExecutors,但你仍然会遇到使用具体类型的错误形式,而不是它的界面。

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

 import Java.util.concurrent.ExecutorService; 
 import Java.util.concurrent.Executors; 
 import Java.util.concurrent.ThreadFactory; 
 
 
公共类PoolSize2 {
 
 public static void main(String [] args){[。_____。] final ThreadGroup threadGroup = new ThreadGroup(“workers”); 
 
 ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactory(){[。_____。] public Thread newThread(Runnable r){[。_____。]返回新的Thread(threadGroup,r); 
} 
}); 
 
 System.out.println(threadGroup.activeCount()); 
} 
} 
10
Dave Cheney

我遇到了同样的问题,因此创建了一个简单的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的状态

Ex

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