Comment interrompre un thread dans un rapide et propre en java?

Essayer d'interruption() comme certains l'ont dit pour voir si cela fait une différence pour votre thread. Si pas, essayez de détruire ou de fermeture d'une ressource qui va faire le fil d'arrêt. Qui a une chance d'être un peu mieux que d'essayer de lancer le Thread.stop() à lui.

Si la performance est tolérable, vous pouvez afficher chaque 3D mise à jour comme un discret non-événement interruptible et simplement le laisser fonctionner jusqu'à leur conclusion, de vérifier par la suite si il y a un nouveau dernière mise à jour à effectuer. Cela pourrait faire l'interface graphique un peu agitée pour les utilisateurs, qu'ils seraient en mesure de faire des modifications de cinq, puis de voir les résultats graphiques de la façon dont les choses étaient cinq changements il y a, puis voir le résultat de leur dernière modification. Mais selon combien de temps ce processus, il pourrait être tolérable, et il serait d'éviter d'avoir à tuer le fil. Conception pourrait ressembler à ceci:

boolean stopFlag = false;
Object[] latestArgs = null;

public void run() {
  while (!stopFlag) {
    if (latestArgs != null) {
      Object[] args = latestArgs;
      latestArgs = null;
      perform3dUpdate(args);
    } else {
      Thread.sleep(500);
    }
  }
}

public void endThread() {
  stopFlag = true;
}

public void updateSettings(Object[] args) {
  latestArgs = args;
}

Au lieu de rouler votre propre drapeau booléen, pourquoi ne pas simplement utiliser le fil d'interruption mécanisme déjà dans les threads Java? Selon la façon dont les entrailles ont été mises en œuvre dans le code, vous ne pouvez pas modifier, vous pouvez être en mesure d'abandonner une partie de son exécution trop.

Filetage Extérieur:

if(oldThread.isRunning())
{
    oldThread.interrupt();
    //Be careful if you're doing this in response to a user
    //action on the Event Thread
    //Blocking the Event Dispatch Thread in Java is BAD BAD BAD
    oldThread.join();
}

oldThread = new Thread(someRunnable);
oldThread.start();

Intérieure Exécutable/Thread:

public void run()
{
    //If this is all you're doing, interrupts and boolean flags may not work
    callExternalMethod(args);
}

public void run()
{
    while(!Thread.currentThread().isInterrupted)
    {
        //If you have multiple steps in here, check interrupted peridically and
        //abort the while loop cleanly
    }
}

Accepté la réponse à cette question permet de soumettre des lots de travail dans un thread d'arrière-plan. Ce pourrait être un meilleur modèle pour ça:

public abstract class dispatcher<T> extends Thread {

  protected abstract void processItem(T work);

  private List<T> workItems = new ArrayList<T>();
  private boolean stopping = false;
  public void submit(T work) {
    synchronized(workItems) {
      workItems.add(work);
      workItems.notify();
    }
  }
  public void exit() {
    stopping = true;
    synchronized(workItems) {
      workItems.notifyAll();
    }
    this.join();
  }
  public void run() {
    while(!stopping) {
      T work;
      synchronized(workItems) {
        if (workItems.empty()) {
            workItems.wait();
            continue;
        }
        work = workItems.remove(0);
      }
      this.processItem(work);
    }
  }
}

L'utilisation de cette classe, l'étendre, en fournissant un type de T et de mise en œuvre de processItem(). Puis il suffit de construire l'un et l'appel de la méthode start() sur elle.

Vous pourriez envisager d'ajouter un abortPending méthode:

public void abortPending() {
  synchronized(workItems) {
    workItems.clear();
  }
}

pour les cas où l'utilisateur a sauté à l'avance du moteur de rendu et vous voulez jeter le travail qui a été prévu jusqu'à présent.

Malheureusement tuer un thread est intrinsèquement dangereux en raison de la possibilité d'utiliser des ressources qui peuvent être synchronisés par des verrous et si le thread vous tuer a actuellement un verrou pourrait entraîner dans le programme dans l'impasse (constante essayer d'attraper une ressource qui ne peut être obtenu). Vous aurez à vérifier manuellement s'il doit être tués depuis le fil que vous souhaitez arrêter. Volatile assurer la vérification de la variable de la valeur vraie, plutôt que quelque chose qui peut avoir été stocké précédemment. Sur une note côté du Fil.rejoindre sur la sortie de fil pour vous assurer d'attendre jusqu'à ce que le thread est en train de mourir réellement disparu avant de vous faire quelque chose plutôt que de vérifier tout le temps.

Je suggère que vous venez d'éviter que plusieurs Threads en utilisant les attendre et de les informer, de sorte que si l'utilisateur change la valeur du nombre de fois qu'il sera exécuté uniquement le Fil une fois. Si l'utilisateur modifie la valeur de 10 fois, il va déclencher le Fil lors de la première modification, puis toutes les modifications apportées avant le Thread est fait tout obtenir "roulé" dans une seule notification. Qui ne s'arrêtent pas d'un Fil, mais il n'y a pas de bonnes façons de faire en fonction de votre description.

La façon que j'ai mis en place quelque chose comme cela dans le passé, est de mettre en œuvre un shutdown() méthode dans mon Runnable sous-classe qui définit une variable d'instance appelée should_shutdown de vrai. Le run() méthode normalement fait quelque chose dans une boucle, et de vérifier régulièrement les should_shutdown et quand il est vrai, des retours ou des appels do_shutdown() et puis revient.

Vous devez conserver une référence à l'actuel thread de travail à portée de main, et lorsque l'utilisateur modifie une valeur, appelez shutdown() sur le thread en cours, et de l'attendre à l'arrêt. Ensuite, vous pouvez lancer un nouveau thread.

Je vous déconseille d'utiliser Thread.stop comme il a été rendu obsolète la dernière fois que j'ai vérifié.

Edit:

Lire votre commentaire à propos de la façon dont votre thread appelle simplement une autre méthode qui prend un certain temps à s'exécuter, de sorte que le ci-dessus ne s'applique pas. Dans ce cas, votre seul véritable options sont d'essayer d'appeler interrupt() et voir si a aucun effet. Si pas, envisager quelque sorte manuellement provoquer de la fonction de votre thread de travail est l'appel à la rupture. Par exemple, on dirait qu'elle est en train de faire certains complexes de rendu, donc peut-être détruire la toile et de l'amener à lever une exception. Ce n'est pas une solution sympa, mais autant que je peux dire, ce est la seule façon d'arrêter un thread dans suituations comme ça.

Au lieu de jouer avec le fil de départ et d'arrêt, avez-vous envisagé d'avoir le fil d'observer les propriétés que vous passez par le biais de votre interface? Vous allez à un certain point encore envie d'une condition d'arrêt pour votre thread, mais cela peut être fait, ce fut ainsi. Si vous êtes un fan de la MVC, cela s'intègre bien dans ce genre de conception

Désolé, après re-lecture de votre question, ni le présent, ni l'une de l'autre "vérifier la variable" suggestions pour résoudre votre problème.

Peut-être cela peut vous aider: Comment peut-on tuer un thread en cours d'exécution en Java?

Vous pouvez tuer un thread particulier en définissant une classe externe variable.

 Class Outer
 {    
    public static flag=true;
    Outer()
    {
        new Test().start();
    } 
    class Test extends Thread
    {               
       public void run()
       {
         while(Outer.flag)
         {
          //do your work here
         }  
       }
    }
  } 

si vous voulez arrêter le fil au-dessus, de définir la variable d'indicateur de false. L'autre façon de tuer un thread est juste de l'enregistrer dans ThreadGroup, puis d'appeler destroy(). De cette façon, peut également être utilisé pour tuer similaire threads par la création de leur groupe ou de vous inscrire avec le groupe.