web-dev-qa-db-fra.com

Java Thread.stop () vs Thread.interrupt ()

J'ai le code suivant:

renderThread = new Thread(new Runnable() {

    @Override
    public void run() {
        for (int i = 0; i < 10000000; i++) {
            System.out.println("Number: " + i);
        }
    }
});

renderThread.start();

try {
    Thread.sleep(100);
} catch (InterruptedException ex) {
    ex.printStackTrace();
}

renderThread.interrupt(); //It should stop, but it does not stop.

renderThread.interrupt() n'interrompt pas le thread, il continue à s'exécuter. Si je remplace renderThread.interrupt() par .stop(), le thread s'arrête. Cependant, .stop() est obsolète . Alors, quelle est la bonne façon d'arrêter un thread si stop est obsolète et que interrupt ne fonctionne pas?

javamultithreading
18
Ágota Horváth

Lorsque vous appelez interrupt (), un indicateur booléen indique à la fonction d'exécution de s'arrêter. C'est pourquoi j'écris habituellement mes fonctions d'exécution comme ceci.

void run()
{
    while(!Thread.interrupted())
    {
        //Do something
    }
}

Ce n’est pas parce que vous appelez interrompre que le fil de discussion s’arrête immédiatement ou du tout. Cela dépend de ce qui est dans la fonction d'exécution.

20
chasep255

Pour vraiment pousser le point pourquoi vous ne devriez pas utiliser Thread.stop()? 

Doug Lea a récemment mentionné que Thread.stop serait la première méthode non implémentée pour Java come Java 8.

Sa réponse à ce commentaire de quelqu'un:

En outre, une autre chose synchronisée a pour aller c'est qu'il gère abandonne async des threads (c'est-à-dire thread.stop ()). Je sais que stop () est obsolète et tout, mais on ne sait jamais.

Était: 

Mais vous savez! À partir de JDK8, Thread.stop est vraiment parti. C'est le première méthode obsolète à avoir été réellement désimplémentée. Maintenant lève simplement UnsupportedOperationException.

http://cs.oswego.edu/pipermail/concurrency-interest/2013-December/012028.html

6
John Vint

Vous devriez jeter un oeil à cet article: http://10kloc.wordpress.com/2013/03/03/Java-multithreading-steeplechase-stopping-threads/

En gros, vous ne devriez pas ARRÊTER un thread (non sécurisé), mais l'interrompre . Ce qui vous manque, c'est que le thread gère l'interruption.

5
brunch875

Tout ce que vous avez besoin de faire pour interrompre le thread en cours ou mettre fin au processus en cours est d’ajouter Ajouter l’instruction ci-dessous dans votre bloc catch

try
{
   Thread.sleep(4000);
   System.out.println("VAS CONSULTING")
}
catch(InterruptedException e)
{
   //Stop printing out VAS CONSULTING
   return;  /*This will terminate the thread*/
}

également si une méthode qui ne déclenche pas d'exception interrompue n'est pas utilisée dans la méthode d'exécutionvous pouvez le faire pour gérer l'interruption de thread ou mettre fin au thread.

@Override
public void run()
{

   System.out.println("VAS CONSULTING");
   if(Thread.Interrupted())
   {
     doSomethingElse();//process something else within the thread
    return; //Terminates the current Thread
   }

}

J'espère que cela vous aide ou aide quelqu'un d'autre.

3
Paul Okeke

renderThread.interrupt () n'interrompt pas le fil, il continue courir.

  • Si le thread est en cours d'exécution et que interrupt() est appelée, son statut d'interruption est défini.
  • Si ce thread est bloqué lors d'une invocation d'une des méthodes wait de la classe Object ou des méthodes Thread.join et Thread.sleep de cette classe, son l'état de l'interruption sera effacé et il recevra une InterruptedException.

Par exemple:

Thread t = new Thread()
      {
          public void run()
          {
              try {
                  for(int i=0; i<10000;i++)
                      System.out.println("Is interrupTed? "+this.isInterrupted());

                  Thread.sleep(200);
              } catch (InterruptedException ex) {
                  Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, ex);
              }

          }
      };
      t.start();
      t.interrupt();
    }

Le code ci-dessus, j’ai utilisé une boucle for pour intercepter le drapeau d’interruption avec isInterrupted() function et l’a imprimé. Comme t.interrupt() est appelé, isInterrupted() renverra true que vous verrez dans la console. Dès qu'il atteindra la Thread.sleep(miliTime), vous verrez que InterruptedException est capturé et lancé comme indiqué ci-dessus. 

Arrêter un fil: 

vous pouvez utiliser cet indicateur isInterrupted() pour vérifier si une interrupt() a été appelée et renvoyer à partir de l'exécution:

Par exemple:

Thread t = new Thread()
      {
          public void run()
          {
              long executeTime = System.currentTimeMillis() ;
              int i = 0;    
              for(; i<10000 && !this.isInterrupted();i++)
                      System.out.println("Is interrupted? "+this.isInterrupted());

               System.out.println("Was Interrupted? "+this.isInterrupted()
                                  +" after cycle: "+ i);
               System.out.println("Time it gets Executed: "
                                  +(System.currentTimeMillis() - executeTime+" ms"));

          }
      };
      t.start();
        try {
            Thread.sleep(200);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
      t.interrupt();

Pendant l’exécution du code ci-dessus: j’ai envoyé le thread principal en veille pour 200 dans la fonction principale statique afin de permettre au thread démarré t de s’exécuter pendant un certain temps. Puis j'ai invoqué
t.interrupt() qui provoque l’arrêt de la boucle for et l’impression d’une sortie comme suit:

Was Interrupted? true after cycle: 1477
Time it gets Executed: 258 ms

Ce qui indique que la boucle for a l'itération 1148 avant que t.interrupt(); soit invoquée dans la fonction main.

Veuillez lire la documentation de Thread.interrupt() function pour plus de détails.

2
Sage

la méthode interrupt () n'arrête pas le thread. lisez ceci pour une explication plus détaillée http://www.ibm.com/developerworks/Java/library/j-jtp05236/

0
csn