Aktive Themen in ExecutorService

Question

Irgendwelche Ideen, wie die Anzahl der aktiven Threads bestimmen zur Zeit in einer laufenden ExecutorService ?

Answer 1

Verwenden Sie einen ThreadPoolExecutor Implementierung und rufen Sie getActiveCount () auf sie:

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

Die ExecutorService Schnittstelle bietet keine Methode für das, es über die Umsetzung abhängig ist.

Answer 2

Unter der Annahme, pool der Name des ExecutorService Beispiel ist:

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

Answer 3

Überprüfen Sie den Quelltext für Executors.newFixedThreadPool ():

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

ThreadPoolExecutor hat eine getActiveCount () -Methode. Sie könnten also entweder warf den ExecutorService zu ThreadPoolExecutor, oder den obigen Code verwenden, um direkt ein zu erhalten. Sie können dann aufrufen getActiveCount ().

Answer 4

Die ExecutorService Schnittstelle wird nicht definiert, ein Verfahren, um die Anzahl der Arbeiter-Threads in dem Pool zu untersuchen, da dies ein Implementierungsdetail ist

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

ist auf der ThreadPoolExecutor Klasse

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

Aber dies erfordert, dass Sie explizit die ThreadPoolExecutor zu erstellen, anstatt die Testamentsvollstrecker Fabrik verwendet, die ExecutorService Objekte zurückgibt. Sie können immer Ihre eigene Fabrik erstellen, den ThreadPoolExecutors zurückgegeben, aber Sie würden immer noch mit der schlechten Form mit dem konkreten Typ, nicht seine Schnittstelle gelassen werden.

Eine Möglichkeit wäre ein eigenen Thread zu schaffen, die Fäden in einer bekannten Fadengruppe erstellt, die Sie dann zählen

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

Answer 5

Ich hatte dasselbe Problem so ein einfaches Runnable erstellt eine ExecutorService Instanz zu verfolgen.

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

    }
}

Sie können einfach mit Ihrem Testamentsvollstrecker verwenden diese Staaten von Threadpool zu bekommen

Ex

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

Answer 6

Platzieren einen statischen flüchtigen Zähler auf dem Faden, der aktualisiert wird, wenn der Faden aktiviert und deaktiviert wird. Siehe auch die API.