Java InterruptedException

InterruptedException tritt auf, wenn ein Thread möglicherweise schläft, wartet oder belegt und unterbrochen ist, bevor oder zum Zeitpunkt der Ausführung einer Aktivität. Manchmal möchte eine Methode testen, ob ein aktueller Thread unterbrochen wurde oder nicht. Wenn es unterbrochen wurde, wird sofort eine Ausnahme ausgelöst. Andernfalls wird es so funktionieren, wie es funktioniert hat. In diesem Thema lernen wir etwas über Java InterruptedException.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Syntax

Um die Ausnahme zu nutzen, müssen Sie die folgende Syntax verwenden:

if (Thread.interrupted ())  // Clears interrupted status!
throw new InterruptedException ();

Hier erstellt die Methode InterruptedException () eine InterruptedException ohne detaillierte Nachricht als Parameter.

Aber wenn es wie eine InterruptedException (String s) ausgelöst wird, wird eine InterruptedException mit bestimmten Details erstellt. Bei dieser Methode ist s die detaillierte Nachricht.

Wie funktioniert InterruptedException in Java?

Hier besprechen wir den Workflow von InterruptedException. Hier können Threads in Multithread-Code oft blockieren; Der Thread hält die Ausführung an, bis eine externe Bedingung erfüllt ist, wie zum Beispiel:

• wenn eine Sperre aufgehoben wird
• oder ein anderer Thread schließt einen Vorgang ab
• und außerdem werden einige E/A-Vorgänge abgeschlossen

Hier können Threads unterbrochen werden. Wenn ein Interrupt auftritt, wird der Thread daran gehindert, die reguläre Arbeit auszuführen, die er verrichtet. Die genaue Reaktion auf den angegebenen Interrupt hängt jedoch vom Status des Threads und davon ab, wie der Thread wie folgt implementiert wird:

Wir werden einen Thread haben, der zum Blockieren von Threads oder früheren Threads verwendet werden kann, die vorhanden waren. Wenn dies abgefangen wird, wird die InterruptedException ausgelöst. Wenn kein Problem vorliegt und kein früherer Thread vorhanden ist, setzt der Thread seine Arbeit fort. Wenn der Thread auf eine Ausnahme stößt, setzt er den unterbrochenen Status des Threads auf „True“. Der Thread fragt in regelmäßigen Abständen die Methode checkInterrupted() ab. Dies ist die bevorzugte Funktionsweise des Threads. Sobald der Prozess abgeschlossen ist, findet eine Bereinigungsaktivität statt. Nach der Bereinigung wird die Ausführung dann gestoppt. Es löst die InterruptedException aus, falls vorhanden, und wenn nicht, fährt es mit seinem normalen Ausführungsablauf fort.

Wenn es zu einer Unterbrechung im oben genannten Prozess kommt, soll der Prozess den Thread nicht sofort schließen. Dies liegt daran, dass es sich mitten in einer Berechnung befindet, die immer stattfindet, und daher warten muss.

Konstrukteure

Konstruktoren sind Java-Objekte, die bei der Initialisierung eines neu erstellten Objekts oder einer neu erstellten Methode helfen. Es handelt sich um eine Java-Instanz, die keinen Rückgabetyp hat. Da das Objekt dadurch initialisiert werden soll, hat es denselben Namen wie die Klasse, zu der es gehört. Daher werden bei jedem Aufruf des Objekts automatisch Konstruktoren aufgerufen und initialisiert. Unten finden Sie eine Konstruktormethode.

InterruptedException ()

Hier erstellt diese Methode eine Ausnahme ohne Nachricht. Hier wird eine Instanz der InterruptedException-Klasse erstellt. In diesem Konstruktor wird der Nachrichtenparameter auf null gesetzt.

Beispiel:

public InterruptedException () InterruptedException (String s)

In dieser Methode der InterruptedException-Klasse wird der Parameter als angegebene Nachricht im Format der Zeichenfolge verwendet. Hier erklärt der String-Parameter den Namen der Klasse, die den Fehler ausgelöst hat.

Beispiel für InterruptedException

Jetzt schauen wir uns ein Beispiel an, bei dem ein Thread unterbrochen wird:

// Java Program to check how
// interrupt () method  works
// simultaneously while a thread stops working
class CheckInterruption extends Thread {
public void run ()
{
try {
Thread.sleep (2000);
System.out.println ( "We are checking Interrupted Exception");
}
catch (InterruptedException e) {
throw new RuntimeException ( "Thread is" + "interrupted");
}
}
public static void main (String args[])
{
CheckInterruption t1 = new CheckInterruption ();
t1.start ();
try {
t1.interrupt ();
}
catch (Exception e) {
System.out.println ("Exception handled");
}
}
}

Ausgabe:

Der obige Code hilft uns, das Konzept der unterbrochenen Ausnahme zu verstehen. Wir haben eine Klasse, CheckInterruption, die die Thread-Klasse von Java erweitert. Anschließend wird im Try-Block nach der Ausnahme gesucht. Wenn es eine Ausnahme gibt, wird diese im Catch-Block abgefangen und die Ausgabe wird als Catch-Block angezeigt. Dies ist in unserem Beispiel der Fall, wo die Unterbrechung abgefangen und die erforderliche Ausgabe angezeigt wird. Das Programm wird jedoch nicht abgeschlossen, da der Catch-Block die in Java vorhandene Exception()-Methode aufruft. Schauen wir uns nun ein Beispiel an, bei dem die Ausnahme abgefangen wird und dann der nächste Thread beginnt.

class CheckInterruptingThread2 extends Thread{
public void run (){
try{  Thread.sleep (1000);
System.out.println ("task");
}catch (InterruptedException e){
System.out.println ("Exception is handled "+e);  }
System.out.println ("thread is now in running state...");
}
public static void main (String args[]){
CheckInterruptingThread2 t1=new CheckInterruptingThread2 ();
t1.start ();
t1.interrupt ();
}
}

Ausgabe:

The above program uses a class that is again extending the Thread class in Java. In the try () block, we make the thread sleep for some time, and then the catch block catches the exception when it is encountered. Once it is handled, the message is printed, and then the interrupt () method is called, after which the next thread moves to the running state. The same is displayed after the method call is finished and the thread starts working.

How to avoid InterruptedException?

The solution to this exception is you can stop making use of thread.sleep () method. Instead of this method, the more efficient method will be SystemClock.sleep () method. Another replacement for the above-mentioned method can be using TimeCOunter, which will depend on the logic and code where it is being used. This can also be an optimal solution.

If at all you would still like to make use of thread.sleep () then it should be used as below.

try {
Thread.sleep ();
} catch (InterruptedException e) {
Thread.currentThread ().interrupt (); /* this line will see to it that Thread.interrupted () always returns true */
throw new RuntimeException (e);
}

Conclusion – Java InterruptedException

As the word exception suggests, it is a state which can be checked and allowed to pass in some cases. InterruptedException happens when a thread waits or sleeps, and other threads are interrupted and cannot proceed further. We can handle this exception by either using proper try-catch blocks or by avoiding the usage of the sleep () method.

Das obige ist der detaillierte Inhalt vonJava InterruptedException. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!