Java-Planung

  1. Planen eines Prozesses mit den Methoden der Schnittstelle ScheduledExecutorService in Java
  2. Planen Sie einen Thread mit der Klasse Timer in Java

Scheduling ist der Prozess der Ausführung einer Aufgabe oder einer Funktion in einem festen Zeitintervall. Das Scheduling findet seinen Einsatz beim Ausführen von Batch-Prozessen, beim Senden von ereignisbasierten Triggern wie Geburtstagswünschen und beim Senden von Push-Benachrichtigungen. Diese Prozesse müssen zu einer genau definierten Zeit basierend auf den gegebenen Bedingungen und Zeitintervallen ausgeführt werden.

Planen eines Prozesses mit den Methoden der Schnittstelle ScheduledExecutorService in Java

package scheduling;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class ScheduleTask {
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
        Runnable executeTask = () -> {
            counter++;
            System.out.println("Task" + counter);
        };

        ScheduledFuture<?> scheduleAtFixedRate = service.scheduleAtFixedRate(executeTask, 5, 1, TimeUnit.SECONDS);

        while (true) {
            Thread.sleep(1000);
            if (counter == 5) {
                System.out.println("Stopping the scheduled task!");
                scheduleAtFixedRate.cancel(true);
                service.shutdown();
                break;
            }
        }
    }
}

Im obigen Code wird zuerst eine statische Zählervariable auf den Wert Null initialisiert. Der newScheduledThreadPool ist eine statische Methode der Klasse Executors. Die Methode erstellt einen Thread-Pool, der regelmäßig mit dem in der Argumentliste angegebenen Parameter ausgeführt werden soll. In unserem Fall wird also ein einzelner Thread zur Ausführung erstellt, da der Parameter in der Argumentliste der Methoden die Anzahl der Thread-Pools definiert. Die Methode gibt eine Instanz von ScheduledExecutorService zurück, die in der Referenzvariablen service gespeichert wird und IllegalArgumentException auslöst, wenn die Poolgröße kleiner als Null ist.

Das Runnable ist eine Schnittstelle, die jede Klasse erweitern kann und ist die funktionale Schnittstelle. Sie hat nur eine statische Methode als run-Methode und ist für die Ausführung des Threads bestimmt. Unter Verwendung des Lambda-Ausdrucks, ausgedrückt als Symbol in Klammern ()-> und einem Pfeil, gibt die Struktur an, dass wir keine Argumente an die Methode run übergeben. Die Anweisungen haben wir in der Definition der Methode run definiert. Die im Block vorhandene Anweisung erhöht die Zählervariable und gibt die Aufgabe in der Konsolenausgabe aus. Auf all diese Anweisungen wird durch die Variable namens executeTask-Variable verwiesen.

Die Referenzvariable service ruft die Methode scheduleAtFixedRate der Schnittstelle ScheduledExecutorService auf. Die Methode erstellt und führt die periodische Aufgabe aus, die nach der anfänglichen Verzögerung und später innerhalb des angegebenen Zeitraums ausgeführt werden soll. Es braucht vier Parameter, einen ausführbaren Befehl, der ausgeführt werden soll, und die Variable initialDelay ist die Zeit, um die erste Ausführung zu verzögern, period bezeichnet die Dauer zwischen aufeinanderfolgenden Ausführungen und unit ist die Zeiteinheit in Sekunden , Minuten und Stunden. Der Thread beginnt mit der Ausführung, sobald die Methode aufgerufen wird.

In der while-Schleife wird zunächst der aktuell ausgeführte Thread in den Ruhezustand versetzt. Die Methode Thread.sleep() hält den aktuell ausgeführten Thread vorübergehend für die definierte Zeit an. Der Parameter ist die Zahl in Millisekunden, für die der aktuelle Arbeitsthread angehalten werden soll. Die Methode wirft IllegalArgumentException, wenn der Wert negativ ist und InterruptedException, wenn der aktuelle Thread unterbrochen wird. Später wird der Wert eines Zählers mit einem definierten Wert überprüft. Diese Prüfung wird angewendet, um die while-Methode für eine bestimmte Anzahl von Malen auszuführen. Andernfalls arbeitet der Block für eine unendliche Zahl, die niemals endet. Im Block while ruft die Variable scheduleAtFixedRate die Methode cancel auf, die die aktuelle Ausführung des Threads abbricht. Die Funktion nimmt auch einen booleschen Parameter entgegen, der angibt, ob der aktuell ausgeführte Thread unterbrechen darf oder nicht.

Die Methode service.shutdown leitet den Shutdown-Prozess ein, bei dem zuvor übergebene Aufgaben ausgeführt werden sollen und nichts Neues angenommen wird.

Die Ausgabe des obigen Codeblocks ist wie folgt.

Task1
Task2
Task3
Task4
Task5
Stopping the scheduled task!

Planen Sie einen Thread mit der Klasse Timer in Java

Unten sehen Sie den einfachen Codeblock, der zwei benutzerdefinierte Klassenobjekte mithilfe seiner Konstruktoren instanziiert. TimerImplementation ist die benutzerdefinierte Klasse dafür. Es wird eine Instanz von Timer erstellt, die einen neuen Thread erstellt. Das neu erstellte Objekt eines Timers ruft dann die Methode scheduleAtFixedRate auf. Diese Methode verwendet Parameter als task, die geplant werden muss, delay verzögert die Aufgabe in Millisekunden und period ist die Zeit in Millisekunden für die sukzessive Ausführung.

package timer;

import java.util.Timer;

public class UsingTimerClass {
    public static void main(String[] args) {
        TimerImplementation timer1 = new TimerImplementation("Thread1");
        TimerImplementation timer2 = new TimerImplementation("Thread2");

        Timer t = new Timer();
        t.scheduleAtFixedRate(timer1, 0, 2000);
        t.scheduleAtFixedRate(timer2, 0, 1000);
    }
}

Unten ist die Implementierung der benutzerdefinierten Klasse. Die Klasse TimerImplementation erweitert die abstrakte Klasse TimerTask, die eine einzelne abstrakte Methode namens run enthält. Wir erweitern die Klasse TimerTask um eine benutzerdefinierte Klasse, dann wird die Methode run überschrieben.

Die Klasse verfügt über einen benutzerdefinierten Konstruktor, der den benutzerdefinierten Namen auf das Thread-Objekt festlegt.

Wir können die eigentliche Logik in der Methode “run” des Threads angeben. Es enthält eine Anweisung als print, die den Namen des aktuell ausgeführten Threads ausgibt. Thread.currentThread().getName() gibt den Namen des aktuell ausgeführten Threads zurück. Die Sleep-Methode wird über Thread1 aufgerufen, die die Ausführung für 1000 Millisekunden unterbricht. Die Methode sleep wirft InterruptedException, wenn ein Thread den aktuellen Thread unterbricht, und wird deshalb in den try-catch-Block eingeschlossen.

package timer;

import java.util.TimerTask;

public class TimerImplementation extends TimerTask {

    private String name;

    public TimerImplementation(String n) {
        this.name = n;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " " + name);
        if ("Thread1".equalsIgnoreCase(name)) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Unten ist die nie endende Ausgabe des obigen Codes. Da wir in der Methode run keine Beendigungsbedingung definiert haben, wird der Thread endlos ausgeführt, bis ein externer Stopp angewendet wird, um die Ausführung des Hauptthreads zu beenden.

Timer-0 Thread1
Timer-0 Thread2
Timer-0 Thread2
Timer-0 Thread2
Timer-0 Thread1
Timer-0 Thread2
Timer-0 Thread2
Timer-0 Thread1
Timer-0 Thread2