it-swarm-es.com

Subprocesos activos en ExecutorService

¿Alguna idea de cómo determinar el número de subprocesos activos que se ejecutan actualmente en una ExecutorService ?

57
zanussi

Use un ThreadPoolExecutor implementación y llame getActiveCount () en él

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

La interfaz ExecutorService no proporciona un método para eso, depende de la implementación.

63
Daan

Suponiendo que pool es el nombre de la instancia ExecutorService:

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

Verifique el código fuente de Executors.newFixedThreadPool ():

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

ThreadPoolExecutor tiene un método getActiveCount (). Por lo tanto, puede convertir el ExecutorService en ThreadPoolExecutor, o usar el código anterior directamente para obtener uno. A continuación, puede invocar getActiveCount ().

21
Arno

La interfaz ExecutorService no define un método para examinar el número de subprocesos de trabajo en el grupo, ya que este es un detalle de implementación

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

Está disponible en la clase ThreadPoolExecutor

 import Java.util.concurrent.LinkedBlockingQueue; 
 import Java.util.concurrent.ThreadPoolExecutor; 
 import Java.util.concurrent.TimeUnit; 
 
 .] 
 clase pública PoolSize {
 
 public static void main (String [] args) {
 ThreadPoolExecutor executor = new ThreadPoolExecutor (10, 20, 60L, TimeUnit .SECONDS, nuevo LinkedBlockingQueue ()); 
 System.out.println (executor.getPoolSize ()); 
} 
} 

Pero esto requiere que usted cree explícitamente el ThreadPoolExecutor, en lugar de usar la fábrica de Ejecutores que devuelve objetos ExecutorService. Siempre puede crear su propia fábrica que devuelva ThreadPoolExecutors, pero aún se quedaría con la mala forma de usar el tipo concreto, no su interfaz.

Una posibilidad sería proporcionar su propio ThreadFactory que crea subprocesos en un grupo de subprocesos conocido, que luego puede contar

 import Java.util.concurrent.ExecutorService; 
 import Java.util.concurrent.Executors; 
 import Java.util.concurrent.ThreadFactory; 
 
 
 clase pública 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 ()); 
} 
} 
10
Dave Cheney

Tuve el mismo problema, así que creé un Runnable simple para rastrear una instancia del Servicio de Ejecución.

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 ######");
        }

    }
}

Simplemente puede usar esto con su ejecutor para obtener los estados de ThreadPool

Ex

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