Java interrompuException

InterruptedException se produit lorsqu'un thread peut être en veille, en attente ou est occupé et interrompu avant ou au moment de l'exécution d'une activité. Parfois, une méthode peut vouloir tester si un thread en cours a été interrompu ou non. S'il a été interrompu, une exception sera immédiatement levée. Sinon, cela fonctionnera comme avant. Dans cette rubrique, nous allons découvrir Java InterruptedException.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe

Pour utiliser l'exception, vous devez utiliser la syntaxe suivante :

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

Ici, la méthode InterruptedException () crée une InterruptedException sans message détaillé en tant que paramètre.

Mais s'il est lancé comme InterruptedException (String s), il crée une InterruptedException avec des détails spécifiques. Dans cette méthode, s est le message détaillé.

Comment InterruptedException fonctionne-t-il en Java ?

Ici, nous discuterons du flux de travail d'InterruptedException. Ici, dans le code multithread, les threads peuvent souvent se bloquer ; le thread suspend l'exécution jusqu'à ce qu'une condition externe soit remplie, telle que :

• quand un verrou est libéré
• ou un autre thread termine une opération
• et aussi, certaines opérations d'E/S sont terminées

Ici, les discussions peuvent être interrompues. Lorsqu'une interruption se produit, elle empêche le thread d'effectuer le type de travail habituel qu'il effectue. Mais la réponse exacte à l'interruption spécifiée dépend de l'état du thread et de la manière dont le thread sera implémenté comme ci-dessous :

Nous aurons un fil de discussion qui pourra être utilisé pour bloquer les fils de discussion ou les fils de discussion antérieurs qui étaient présents. Lorsque cela est détecté, il lève l'InterruptedException. S'il n'y a pas de problème et qu'il n'y a pas de fil de discussion antérieur, le fil de discussion continue son travail. Lorsque le thread rencontre une exception, il définit le statut interrompu du thread sur true. Le thread interrogera la méthode checkInterrupted () à intervalles réguliers. Il s’agit de la manière privilégiée dont le thread est censé fonctionner. Une fois le processus terminé, une activité de nettoyage a lieu. Après nettoyage, l’exécution est alors arrêtée. Il lève l'InterruptedException, le cas échéant, et sinon, il continue son flux d'exécution normal.

S'il y a une interruption dans le processus ci-dessus, le processus n'est pas censé fermer le fil immédiatement. En effet, il sera au milieu d'un calcul, ce qui se produira toujours et il faudra donc attendre.

Constructeurs

Les constructeurs sont des objets Java qui aident à initialiser un objet ou une méthode nouvellement créé. Il s'agit d'une instance Java qui n'a aucun type de retour. Comme ceci est censé initialiser l'objet, il porte le même nom que la classe à laquelle il appartient. Par conséquent, chaque fois que l’objet est appelé, les constructeurs sont appelés automatiquement et initialisés. Vous trouverez ci-dessous une méthode de constructeur.

InterruptedException ()

Ici, cette méthode crée une exception sans message. Une instance de la classe InterruptedException est en cours de création ici. Dans ce constructeur, le paramètre de message est défini sur null.

Exemple :

public InterruptedException () InterruptedException (String s)

Dans cette méthode de classe InterruptedException, le paramètre est utilisé comme un message spécifié au format de la chaîne. Ici, le paramètre string explique le nom de la classe qui a généré l'erreur.

Exemple sur InterruptedException

Nous allons maintenant examiner un exemple où un fil de discussion est interrompu :

// 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");
}
}
}

Sortie :

Le code ci-dessus nous aide à comprendre le concept d'exception interrompue. Nous avons une classe, CheckInterruption, qui étend la classe Thread de Java. Il recherche ensuite l'exception dans le bloc try. S'il y a une exception, elle est interceptée dans le bloc catch et la sortie est affichée sous forme de bloc catch. C'est le cas dans notre exemple où l'interruption est détectée et la sortie nécessaire est affichée. Mais le programme n'est pas terminé car le bloc catch appelle la méthode Exception() présente en Java. Vérifions maintenant un exemple où l'exception est interceptée, puis le fil de discussion suivant démarre.

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 ();
}
}

Sortie :

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!