So implementieren Sie die Methodeexecute() von ThreadPoolExeceutor in Java

Der Thread-Pool in Java funktioniert so, dass er die Threads behält und bei Bedarf aus dem Pool verwendet. Wann immer eine Aufgabe einen Thread benötigt, stellt der Thread-Pool ihn der entsprechenden Aufgabe zur Verfügung und gibt ihn nach der Verwendung an den Pool zurück. Es verwendet die im Pool vorhandenen Threads wieder, ohne dass neue Threads erstellt werden.

In diesem Artikel wird die Methodeexecute() von ThreadPoolExececutor in Java ausführlich besprochen.

ThreadPoolExecutor-execute()-Methode in Java

Die Methodeexecute() von Java ist für die Ausführung der angegebenen Aufgabe verantwortlich. Die Aufgabe wird aus dem bereits vorhandenen Thread-Pool ausgeführt oder es wird ein neuer Thread erstellt.

Nachfolgend finden Sie die Syntax der Methodeexecute():

Public void execute(task)

Beispiel 1: Implementierung der Methodeexecute()

Die Implementierung der Methodeexecute() ist im folgenden Code dargestellt:

//Import the required packages
import java.util.concurrent.*;
import java.lang.Thread;
import java.util.logging.*;

//Create a class for the execute method
class Threadexceute {
    public static void main(String[] args) {
        // Create two threads
        Maintask firsttask = new Maintask("Thread 1");
        Maintask secondtask = new Maintask("Thread 2");
        // The threads will start working
        System.out.println("The Threads will Start");
        ThreadPoolExecutor threadexe = (ThreadPoolExecutor) Executors.newCachedThreadPool();
        // The execute method will start the first task to start
        threadexe.execute(firsttask);
        // The execute will start the second task to start
        threadexe.execute(secondtask);
        // Close the worker thread
        threadexe.shutdown();
        System.out.println("Threads started, main ends\n");
    }
}

// This method makes the thread run by its run() method
class Maintask implements Runnable {
    private final int sleepTime;
    private final String tName;

    public Maintask(String name) {
        // The name of the thread and the time for which the thread will sleep.
        tName = name;
        sleepTime = 2000;
    }

    // The run() method of Runnable interface.
    public void run() {
        // The output statement that the thread will sleep for this specified time.
        System.out.printf("%s will go to sleep for %d milliseconds.\n", tName, sleepTime);
        try {
            // Make the thread to sleep
            Thread.sleep(sleepTime);
            // the exception for tasks that have not been submitted.
        } catch (InterruptedException e) {
            Logger.getLogger(Maintask.class.getName()).log(Level.SEVERE, null, e);
        }
        System.out.printf("%s has completed sleeping\n", tName);
    }
}

In diesem Java-Code:

  • Den Threads wurden jeweils zwei Aufgaben vorgelegt.
  • Der ausführen() Die Methode führt die Aufgaben aus dem Thread-Pool aus.
  • Die Runnable-Schnittstelle implementiert die laufen() Methode.
  • Die Runnable-Schnittstelle lässt den Thread für eine bestimmte Zeit ruhen.
  • Der Try-Block enthält die Ruhezeit für die Threads.
  • Die Catch-Blöcke behandeln die Ausnahme von Aufgaben, die nicht übermittelt wurden.

Ausgabe

In der obigen Ausgabe:

  • Die Threads haben begonnen zu funktionieren.
  • Die Threads wurden für die angegebene Dauer in den Ruhezustand versetzt.
  • Die schlafenden Threads werden dann aktiviert und die Methodeexecute() führt die Aufgaben aus.

Abschluss

Der Thread-Pool-Executor verfügt über eine Reihe von Methoden für verschiedene Aufgaben. Die Methodeexecute() der ThreadpoolExecutor-Schnittstelle hilft bei der Ausführung von Aufgaben. Die Aufgaben werden entweder von den verfügbaren Threads im Pool ausgeführt oder es werden neue Threads für die Ausführung von Aufgaben erstellt. Die Methodeexecute() wurde in diesem Artikel ausführlich ausgeführt.

Kommentar verfassen

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

Nach oben scrollen