So implementieren Sie die getActiveCount()-Methode von ThreadPoolExeceutor in Java

Der Thread-Pool in Java ist für die Bereitstellung von Threads zur Ausführung der vorgegebenen Aufgaben verantwortlich. Nach Beendigung der Aufgabe werden die Threads wieder in den Thread-Pool zurückgeführt. Es werden neue Threads erstellt oder die zuvor erstellten Threads werden für die Ausführung von Aufgaben verwendet. Wenn die Aufgabe aus irgendeinem Grund nicht an den Thread-Pool übermittelt wurde, wird sie daher von verwaltet RejectedExecutionHandler.

In diesem Artikel wird die Funktionsweise der getActiveCount()-Methode von ThreadPoolExecutor in Java ausführlich erläutert.

Wie verwende ich die ThreadPoolExecutor getActiveCount()-Methode von Java?

Der getActiveCount() von ThreadPoolExecutor ist in Java dafür verantwortlich, die Anzahl der Threads bereitzustellen, die die Aufgabe aktiv ausführen. Vereinfacht ausgedrückt wird die Anzahl der Threads, die grundsätzlich die bereitgestellte Aufgabe ausführen, über die Methode getActiveCount() ermittelt.

Nachfolgend finden Sie die Syntax der getActiveCount()-Methode:

Public int getActiveCount()

Beispiel: Die Implementierung der getActiveCount()-Methode

Die Code-Implementierung der Methode getActiveCount(), die die Anzahl der aktiven Threads abruft, ist unten dargestellt:

import java.util.concurrent.*;
import java.lang.*;// The Class declared for the activecount method.
class Activecountexample {
    public static void main(final String[] arguments) throws InterruptedException {
        // The newcachedThreadpool for the creation of new threads or reuse of the previously created.
        ThreadPoolExecutor executingthread = (ThreadPoolExecutor) Executors.newCachedThreadPool();
        // The getActiveCount() method to get the number of threads active.
        System.out.println("The Threads that are currently executing are " + executingthread.getActiveCount());
        // First task has been submitted for execution
        executingthread.submit(new newtask());
        //The second task has been submitted for execution
        executingthread.submit(new newtask());
        // Third task has been submitted for execution
        executingthread.submit(new newtask());
        // the shutdown() method to end the tasks.
        executingthread.shutdown();
    }
    // The Runnable interface is implemented by the run() method    static class newtask implements Runnable {
        @Override
        public void run() {
            try {
                Long timespan = (long) (Math.random() * 6);
                // The threads that are currently executing the tasks.
                System.out.println("The name of thread that is currently running: " + Thread.currentThread().getName());
                TimeUnit.SECONDS.sleep(timespan);
                // The threads that have finished executing the tasks.
                System.out
                        .println("The name of thread that has completed running: " + Thread.currentThread().getName());
                // The exception in the catch block
            } catch (InterruptedException f) {
            }
        }
    }
}

In diesem Java-Code:

  • Die benötigten Pakete werden importiert.
  • Um neue Threads zu erstellen oder zuvor erstellte Threads wiederzuverwenden newCached() Methode verwendet wird.
  • Der getActivecount() ruft die Anzahl der Threads ab, die derzeit ausgeführt werden.
  • Drei neue Aufgaben werden zur Ausführung eingereicht.
  • Nach der Ausführung werden diese Aufgaben mit beendet abschalten() Methode.
  • Die neue Aufgabe wird mithilfe von implementiert Lauffähig Schnittstelle.
  • Der laufen() Die Methode der Runnable-Schnittstelle enthält die Zeitspanne, für die die Threads in den Ruhezustand versetzt werden
  • Die println()-Methode von Java druckt die aktuell ausgeführten Threads und Threads, deren Ausführung abgeschlossen ist.

Ausgabe

In der Ausgabe unten sind die aktuell ausgeführten Threads 0. Jeder Thread wird in der angegebenen Reihenfolge ausgeführt, d. h. Thread 3 wird zuerst ausgeführt, dann Thread 2 und am Ende wird Thread 1 ausgeführt. Die abgeschlossenen Threads werden in einer Reihenfolge von 3, 2 und 1 gedruckt. Dies ist die Ausgabe in unserem Fall, wenn die Methode getActiveCount() implementiert wird. Die aktuell laufenden und abgeschlossenen Threads werden normalerweise in zufälliger Reihenfolge angezeigt und können von der folgenden Ausgabe abweichen.

Damit ist die Funktion der getActiveCount()-Methode von ThreadPoolExecutor in Java beendet.

Abschluss

In Java ist das getActiveCount() Die Funktion ThreadPoolExecutor ist dafür verantwortlich, die Anzahl der Threads bereitzustellen, die die Aufgabe aktiv ausführen. Dieser Artikel beschreibt die Funktionsweise und Implementierung der getActiveCount()-Methode anhand von Codebeispielen in Java.

Kommentar verfassen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Nach oben scrollen