Comment faire pour arrêter un thread java gracieusement?

Question

J'ai écrit un fil de discussion, cela prend trop de temps à exécuter et il semble que ce ne soit pas complètement terminé. Je veux arrêter le fil gracieusement. De l'aide ?

Answer 1

La bonne façon de le faire est d'avoir le run() du fil gardée par une variable boolean et le mettre à true de l'extérieur lorsque vous voulez arrêter, quelque chose comme:

class MyThread extends Thread 
{ 
    volatile boolean finished = false; 

    public void stopMe() 
    { 
    finished = true; 
    } 

    public void run() 
    { 
    while (!finished) 
    { 
     //do dirty work 
    } 
    } 
} 

Il était une fois une méthode stop() existait mais comme les états de la documentation

Cette méthode est intrinsèquement dangereuse. L'arrêt d'un thread avec Thread.stop l'amène à déverrouiller tous les moniteurs qu'il a verrouillés (comme conséquence naturelle de l'exception ThreadDeath non cochée propageant la pile). Si l'un des objets précédemment protégés par ces moniteurs était dans un état incohérent, les objets endommagés deviennent visibles aux autres threads, ce qui peut entraîner un comportement arbitraire.

C'est pourquoi vous devriez avoir un garde ..

Answer 2

Créez un booléen volatil stop quelque part. Ensuite, dans le code qui va dans le fil, faire régulièrement

if (stop) // end gracefully by breaking out of loop or whatever 

Pour arrêter le fil, mettre stop à true.

Je pense que vous devez le faire manuellement de cette façon. Après tout, seul le code qui s'exécute dans le thread a une idée de ce qui est et n'est pas gracieux.

Answer 3

Vous ne devriez pas tuer cette discussion d'autre. C'est considéré comme une mauvaise habitude. Cependant, il y a plusieurs façons. Vous pouvez utiliser l'instruction return à partir de la méthode run du thread. Ou vous pouvez vérifier si le fil a déjà été interrompu, puis il annulera son travail. F.e. :

while (!isInterrupted()) { 
    // doStuff 
} 

Answer 4

Vous devez envoyer un message d'arrêt au thread et le thread lui-même doit prendre des mesures si le message a été reçu. Ceci est assez facile, si l'action de longue durée est à l'intérieur boucle:

public class StoppableThread extends Thread { 

    private volatile boolean stop = false; 

    public void stopGracefully() { 
    stop = true; 
    } 

    public void run() { 
    boolean finished = false; 
    while (!stop && !finished) { 
     // long running action - finished will be true once work is done 
    } 
    } 
} 

Answer 5

La mauvaise partie sur l'utilisation d'un drapeau pour arrêter votre fil est que si le fil est en attente ou dormir, alors vous devez attendre à finir d'attendre/dormir. Si vous appelez la méthode d'interruption sur le thread, cela provoquera l'arrêt de l'appel wait ou sleep avec une exception InterruptedException. L'appel à interruption() définit également une propriété interrompue que vous pouvez utiliser comme indicateur pour vérifier s'il faut quitter (dans le cas où le thread n'attend pas ou ne dort pas).

Vous pouvez écrire la méthode d'exécution du thread de sorte que l'exception InterruptedException soit interceptée en dehors de la logique de bouclage du thread ou vous pouvez intercepter l'exception dans la boucle et fermer l'appel en lançant l'exception. catch block pour l'exception InterruptedException afin que le thread ne perd pas de vue le fait qu'il a été interrompu. Le thread interrompu peut toujours garder le contrôle et terminer le traitement selon ses propres termes.Dites que je veux écrire un thread de travail qui fonctionne par incréments, où il y a un sommeil au milieu pour une raison quelconque, et je ne veux pas quitter le sommeil pour arrêter le traitement sans faire le travail restant pour cet incrément , je veux seulement à quitter si elle est en entre les incréments:

class MyThread extends Thread 
{ 
    public void run() 
    { 
     while (!Thread.currentThread().isInterrupted()) 
     { 
      doFirstPartOfIncrement(); 
      try { 
       Thread.sleep(10000L); 
      } catch (InterruptedException e) { 
       // restore interrupt flag 
       Thread.currentThread().interrupt(); 
      } 
      doSecondPartOfIncrement(); 
     } 
    } 
} 

Here is an answer to a similar question, including example code.

Answer 6

pour un fil pour s'arrêter, personne ne semble avoir mentionné (mis) en utilisant exception:

abstract class SelfStoppingThread extends Thread { 

    @Override 
    public final void run() { 
     try { 
      doRun(); 
     } catch (final Stop stop) { 
      //optional logging 
     } 
    } 

    abstract void doRun(); 

    protected final void stopSelf() { 
     throw new Stop(); 
    } 

    private static final class Stop extends RuntimeException {}; 

} 

Une sous-classe a juste besoin de surcharger doRun() normalement comme vous le feriez avec un Thread, et d'appeler stopSelf() chaque fois qu'elle a envie de s'arrêter. IMO est plus propre que d'utiliser un drapeau dans une boucle while.