Java sleep: Alles über die Java Thread sleep()-Methode!

In Java gibt es häufig Situationen, in denen ein Thread für eine bestimmte Zeit in einen Ruhezustand versetzt werden muss. Zum Beispiel, wenn ein Programm zu einem anderen Thread wechseln muss oder um den Ausführungsprozess eines Programms zu verlangsamen. Wie kann man also solche Situationen bewältigen? Mit der Java sleep()-Methode! In Java kann die sleep()-Methode der Thread-Klasse verwendet werden, um mit solchen Situationen umzugehen.

In diesem Artikel werden wir uns mit den unten aufgeführten Aspekten der Java-Methode sleep befassen:

• Was ist die Java sleep()-Methode?
• Grundlegende Syntax der Java sleep()-Methode
• Was ist eine InterruptedException in Java?
• Wie funktioniert die Java sleep()-Methode?
• Praktische Implementierung der Java sleep()-Methode

So, lass uns loslegen!

Was ist die Java sleep()-Methode?

Java sleep() ist eine eingebaute statische Methode (mehr über Java static erfahren) der Klasse java.lang.Thread, die die Ausführung des laufenden Threads für eine bestimmte Zeitspanne pausiert.

Grundlegende Syntax

Die Java Thread-Klasse bietet zwei überladene Versionen der sleep()-Methode:

• Native Methode mit einem Parameter
• Nicht-native Methode mit zwei Parametern

Erste Syntax: Native Methode mit einem Parameter

Werfen wir einen Blick auf das unten stehende Snippet, um die grundlegende Syntax der sleep()-Methode zu verstehen: public static void sleep(long ms) throws InterruptedException

public static void sleep(long ms) throws InterruptedException

Anhand des obigen Schnipsels konnten wir die folgenden Punkte feststellen:

• Die Methode sleep() ist statisch, d. h. wir können sie direkt an einer beliebigen Stelle im Programm mit der Klasse Thread aufrufen.
• Durch das Schlüsselwort void, das die native sleep()-Methode darstellt, gibt die Methode keinen Wert zurück.
• Die native sleep()-Methode benötigt nur einen Parameter, nämlich Zeit in Millisekunden. Sie nimmt die Millisekunden als Parameter und lässt den laufenden Thread für eine bestimmte Zeit schlafen.
• Die native sleep()-Methode kann eine Ausnahme auslösen, daher können Ausnahmen mit dem Schlüsselwort throws oder der Java try-catch Anweisung behandelt werden.

Zweite Syntax: Nicht-native Methode mit zwei Parametern

Hier ist die grundlegende Syntax der nicht-nativen sleep()-Methode:

public static void sleep(long ms, int ns)throws InterruptedException

Der obige Ausschnitt verdeutlicht die unten aufgeführten Punkte:

• Die nicht-native sleep() ist eine statische Java Methode.
• Das Schlüsselwort void, das die nicht-native Methode sleep() repräsentiert, gibt nichts zurück.
• Sie akzeptiert zwei Parameter, nämlich „Zeit in Millisekunden und Zeit in Nanosekunden.
• Millisekunden geben an, wie lange der Thread im Schlafzustand verbleiben wird.
• Nanosekunden geben eine zusätzliche Zeit für die sleep()-Methode an. Die Nanosekunden werden verwendet, wenn der Thread für eine zusätzliche Zeitspanne (mindestens 0ns und höchstens 999999 ns) im Schlafmodus bleiben soll.
• Das Schlüsselwort throws kann verwendet werden, um unterbrochene Ausnahmen zu behandeln.

Was bedeutet InterruptedException in Java?

InterruptedException ist eine Ausnahme in Java, die auftritt, wenn sich der aktuelle Thread in einem schlafenden Zustand befindet und ein anderer Thread ihn unterbricht. Die InterruptedException kann mit dem Schlüsselwort throws oder mit einer try-catch-Anweisung behandelt werden.

Wie funktioniert die sleep()-Methode in Java?

Betrachten wir die unten aufgeführten Punkte, um die Funktionsweise der Methode Thread.sleep() besser zu verstehen:

• Wenn wir die sleep()-Methode aufrufen, stoppt sie die Ausführung des Threads, der zu diesem Zeitpunkt läuft.
• Wir können die sleep()-Methode mit der unten angegebenen Syntax aufrufen: Thread.sleep(benutzerdefinierte Zeit);

Thread.sleep(user-specified time);

• Die Schlafzeit der Threads ist mit den Aktivitäten/Nutzung des Systems verbunden, d.h. wenn das System beschäftigt ist, wird die Schlafzeit des Threads länger als die angegebene Zeit sein.
• Ist das System hingegen weniger ausgelastet, verbleibt der Thread entsprechend der angegebenen Zeit im Schlafmodus.
• In einem Multithreading-Szenario kann ein Thread einen anderen Thread unterbrechen, der sich bereits im Ruhezustand befindet. In einem solchen Fall wird die InterruptedException auftreten.
• Wenn der Benutzer eine negative Zeit angibt, kommt es zudem zu einer IllegalArgumentException. Zeitreisen in die Vergangenheit sind noch nicht möglich :)!

Praktische Umsetzung der sleep()-Methode in Java

Bis jetzt haben wir alle grundlegenden Konzepte der Java-Methode sleep() kennengelernt. Nun ist es an der Zeit, all diese Konzepte praktisch umzusetzen.

Aufgabe 1: Wie verwendet man die Java sleep()-Methode auf dem Hauptthread?

Betrachten wir das unten stehende Programm, um zu verstehen, wie man die sleep()-Methode auf dem Haupt-Thread in Java verwendet:

public class MeinJavaSleep {
    public static void main(String[] args) throws InterruptedException {
        int count = 5;
        while (count <= 10) {
            System.out.println("Ich mach ein kurzes Nickerchen");
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " " +count);
            count++;
        }
    }
}

In dem oben genannten Java-Programm haben wir die folgenden Aufgaben durchgeführt:

• In diesem Beispielprogramm haben wir zunächst das Schlüsselwort throws verwendet, um eine InterruptedException auszulösen, wenn ein Thread einen anderen Thread unterbricht, der sich bereits im Schlafmodus befindet.
• In der Java main Methode haben wir zunächst eine Variable mit dem Namen count erstellt und ihr einen Wert zugewiesen, nämlich 5.
• Dann haben wir die while-Schleife (mehr über Java Schleifen erfahren) verwendet, um eine Schleife zu durchlaufen, bis der Wert von count kleiner oder gleich 10 ist.
• Innerhalb der while-Schleife rufen wir die Methode sleep() auf und übergeben ihr den Wert 2000 Millisekunden. Das bedeutet, dass der Hauptthread nach jeder Iteration für 2 Sekunden in den Schlafmodus übergeht.
• Danach haben wir die Methode currentThread() zusammen mit der Methode getName() aufgerufen, um den Namen des aktuell laufenden Threads zu erhalten.
• Da wir in diesem Beispiel die Java-Methode sleep() für den Haupt-Thread verwenden, ist es nicht erforderlich, die Methode start() der Klasse Thread aufzurufen, um die Ausführung des Threads zu starten.

Die Ausgabe zeigt, dass das obige Java-Programm 12 Sekunden für die Ausführung von 6 Threads benötigt. Dies bestätigt die Funktionsweise der sleep()-Methode.

Aufgabe 2: Wie kann man die Java sleep()-Methode für eigene Threads nutzen?

In diesem Java-Programm werden wir lernen, wie man die sleep()-Methode für einen benutzerdefinierten Thread verwendet:

public class Main extends Thread {
    @Override
    public void run() {
        int count = 8;
        while (count <= 10) {
            System.out.println(Thread.currentThread().getName() + " " + "Counter:" + count);
            try {
                Thread.sleep(2000);
                count++;
            } catch (InterruptedException excep) {
                System.out.println("InterruptedException aufgetreten");
            }
        }
    }
    public static void main(String[] args) {
        Main thread1 = new Main();
        Main thread2 = new Main();
        thread1.start();
        thread2.start();
    }
}

• In diesem Programm erben wir zunächst von der Java-Thread-Klasse.
• Dann überschreiben wir die run()-Methode. (Mehr über die Java Override Annotation erfahren)
• Wir rufen die sleep()-Methode auf und übergeben ihr 2000 Millisekunden.
• Schließlich verwenden wir die start()-Methode, um die Threads zu starten.

Die Ausgabe zeigt, dass bei der Ausführung eines benutzerdefinierten Threads der Thread-Name zusammen mit dem Wert der Variablen count nach jeweils 2 Sekunden angezeigt wird. Zwischen den angegebenen Zeitintervallen aktiviert der Thread seinen Schlafmodus.

Aufgabe 3: Negative Zeit weitergeben

Dieses Programm soll helfen zu verstehen, was passiert, wenn wir der Methode sleep() eine negative Zeit übergeben:

public class JavaSleepExample {
    public static void main(String[] args) throws InterruptedException {
        int count = 5;
        while (count <= 10) {
            Thread.sleep(-2000);
            System.out.println(Thread.currentThread().getName() +   + count);
            count++;
        }
    }
}

Diesmal geben wir einen negativen Wert als Schlafzeit an, d. h. -2000 Millisekunden, weshalb die Methode sleep() die folgende Ausgabe erzeugt:

Die Ausgabe zeigt, dass der Compiler eine IllegalArgumentException auslöst, wenn wir einen negativen Wert an die Java sleep()-Methode übergeben.

Zusammenfassung: Die Java sleep()-Methode

Java sleep() ist eine eingebaute statische Methode der Klasse Thread, die dazu dient, die Ausführung des aktuell ausgeführten Threads anzuhalten. Der Aufruf der sleep()-Methode stoppt die Ausführung des aktuellen Threads und versetzt ihn für eine bestimmte Zeit in den Schlafzustand. Die InterruptedException tritt auf, wenn sich der aktuelle Thread in einem schlafenden Zustand befindet und von einem anderen Thread unterbrochen wird; sie kann jedoch mit der try-catch-Anweisung oder dem Schlüsselwort throws behandelt werden. In diesem Beitrag wurde die Verwendung der Methode Thread.sleep() anhand einiger geeigneter Beispiele erläutert.