Comment interrompre un thread en cours d'exécution en Java(1)

Le multithreading présente un nouvel ensemble de problèmes pour les programmeurs pendant le processus de programmation, et comment interrompre un thread en cours d'exécution est l'un des problèmes. Dans cet article, l'auteur décrira les méthodes associées.

La procédure est très simple. Cependant, le multithreading présente un nouvel ensemble de défis pour les programmeurs qui, s'ils ne sont pas résolus de manière appropriée, peuvent conduire à un comportement inattendu et à des erreurs subtiles et difficiles à trouver.

Dans cet article, nous abordons l'un de ces problèmes : comment interrompre un thread en cours d'exécution.

Interrompre un thread en arrière-plan signifie arrêter tout ce que le thread fait avant qu'il ne termine sa tâche, abandonnant ainsi son opération en cours. Que le thread meure, attende une nouvelle tâche ou passe à l'étape suivante dépend de ce programme. Même si cela peut paraître simple au premier abord, vous devez faire preuve de prudence pour obtenir les résultats souhaités. Vous feriez mieux de garder les avertissements suivants à l’esprit.

Tout d’abord, oubliez la méthode Thread.stop. Bien qu'elle arrête un thread en cours d'exécution, cette méthode n'est pas sûre et n'est pas recommandée, ce qui signifie que dans une future version de Java, elle n'existera plus.

Certains téméraires peuvent être trompés par la méthode alternative Thread.interrupt. Malgré ce que son nom semble impliquer, cette méthode n'interrompt pas un thread en cours d'exécution (nous y reviendrons plus tard), comme décrit dans le listing A. Il crée un thread et tente de l'arrêter à l'aide de la méthode Thread.interrupt. L'appel à la méthode Thread.sleep() laisse suffisamment de temps au thread pour s'initialiser et se terminer. Le thread lui-même ne participe à aucune opération utile.

class Example1 extends Thread {
            boolean stop=false;
            public static void main( String args[] ) throws Exception {
            Example1 thread = new Example1();
            System.out.println( "Starting thread..." );
            thread.start();
            Thread.sleep( 3000 );
            System.out.println( "Interrupting thread..." );
            thread.interrupt();
            Thread.sleep( 3000 );
            System.out.println("Stopping application..." );
            //System.exit(0);
            }
            public void run() {
            while(!stop){
            System.out.println( "Thread is running..." );
            long time = System.currentTimeMillis();
            while((System.currentTimeMillis()-time < 1000)) {
            }
            }
            System.out.println("Thread exiting under request..." );
            }
            }

Si vous exécutez le code du listing A, vous verrez le résultat suivant sur la console :

Starting thread...
Thread is running...
Thread is running...
Thread is running...
Interrupting thread...
Thread is running...
Thread is running...
Thread is running...
Stopping application...
Thread is running...
Thread is running...
Thread is running...
.....................

Même après l'appel de Thread.interrupt(), le thread continue toujours à fonctionner.

Interrompre réellement un thread

Le moyen le meilleur et le plus recommandé d'interrompre un thread est d'utiliser une variable partagée pour signaler que le thread doit arrêter la tâche en cours. Le thread doit vérifier périodiquement cette variable (notamment lors d'opérations redondantes) puis terminer la tâche de manière ordonnée. Le listing B décrit cette approche.

Listing B
class Example2 extends Thread {
  volatile boolean stop = false;
  public static void main( String args[] ) throws Exception {
    Example2 thread = new Example2();
   System.out.println( "Starting thread..." );
   thread.start();
   Thread.sleep( 3000 );
   System.out.println( "Asking thread to stop..." );
   thread.stop = true;
   Thread.sleep( 3000 );
   System.out.println( "Stopping application..." );
   //System.exit( 0 );
  }
  public void run() {
    while ( !stop ) {
     System.out.println( "Thread is running..." );
      long time = System.currentTimeMillis();
      while ( (System.currentTimeMillis()-time < 1000) && (!stop) ) {
      }
    }
   System.out.println( "Thread exiting under request..." );
  }
}

L'exécution du code dans le listing B produira le résultat suivant (notez comment les threads se terminent de manière ordonnée)

Starting thread...
Thread is running...
Thread is running...
Thread is running...
Asking thread to stop...
Thread exiting under request...
Stopping application...

Bien que cette méthode nécessite un peu de codage, ce n'est pas le cas difficile à réaliser. En même temps, cela donne aux threads la possibilité d'effectuer le travail de nettoyage nécessaire, ce qui est absolument nécessaire dans toute application multithread. Assurez-vous de définir la variable partagée comme volatile ou d'encadrer tous les accès à celle-ci dans des blocs/méthodes synchronisés.

Jusqu’ici tout va bien ! Mais que se passe-t-il lorsqu'un thread est bloqué en attendant qu'un événement se produise ? Bien entendu, si le thread est bloqué, il ne peut pas vérifier les variables partagées et ne peut pas s'arrêter. Cela se produit dans de nombreuses situations, par exemple lors de l'appel d'Object.wait(), ServerSocket.accept() et DatagramSocket.receive(), pour n'en nommer que quelques-unes.

Ils peuvent bloquer le fil de façon permanente. Même si un délai d'attente se produit, il n'est pas possible ni approprié de continuer à attendre avant l'expiration du délai. Par conséquent, un mécanisme doit être utilisé pour permettre au thread de quitter l'état bloqué plus tôt.

Malheureusement, il n'existe pas de mécanisme de ce type qui fonctionne dans toutes les situations, mais il existe des techniques spécifiques qui peuvent être utilisées en fonction de la situation. Dans les liens suivants, je répondrai aux exemples les plus courants.

Ce qui précède explique comment interrompre un thread en cours d'exécution (1) en Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !