J'écris une application qui reproche plusieurs tâches simultanées. J'utilise un piscine de fil pour mettre en œuvre cela.
Il peut arriver qu'un événement survient que les calculs étant effectués dans les tâches invalides. Dans ce cas, j'aimerais arrêter les tâches actuellement en cours d'exécution et commencer de nouvelles.
Mon problème: Comment puis-je arrêter les tâches actuellement en cours? La solution que j'ai implémentée consiste à stocker une référence au thread de tâche et à appeler et la méthode principale est la suivante: est-ce une bonne solution ou y a-t-il un Meilleur moyen d'arrêter un fil de courant dans une piscine de fil? interruption () sur ce fil. En code de démonstration:
4 Réponses :
dans votre version exécutée () méthode vous boucle pour toujours avec tandis que (vrai) . Le comportement standard serait d'avoir un Boolean Runindicator que la méthode exécuter () définit true quand il démarre et que votre boucle doit alors être tandis que (exécutinateur) . Votre méthode STOP () doit être défini exécutinicator = false de sorte que la prochaine itération de la boucle tombera.
Dans cette implémentation, la méthode stop () doit également appeler ceci.Interrupt () . Dans la mise en œuvre effective, il devrait y avoir une méthode similaire que vous pouvez utiliser pour arrêter tout ce qui est lourd au lieu du fichier thread.sleep * (4000) appel. Vous pouvez utiliser une méthode très similaire sur le exécutininicator pour y accomplir.
@Erick, interruption () n'est pas une méthode de runnable. Ce n'est donc pas possible. thread.CurrentThread (). Interruption () ne fonctionnerait pas non plus parce que l'appel de l'arrêt () se produit dans un autre fil que celui que vous souhaitez interrompre.
Désolé, je n'ai pas attrapé ça. Je prolonge toujours thread au lieu de exécutable , donc j'ai toujours accès à ces choses. Je ferais la même chose ici. Cela résoudrait également le problème mineur de threadsafe que vous avez posté dans votre réponse.
Bon point sur la sécurité du fil. L'avantage de l'utilisation de Runnable est que vous pouvez soumettre les travaux au threadpool et de maximiser le nombre de threads exécutés sur. Cela réduira les coûts de performance (les threads sont assez coûteux à utiliser) et si vous utilisez un threadpool avec un seul thread, vous pouvez être sûr que la tâche soumise en premier est également terminée.
@TTTlerlerner, un piscine soumis à une piscine de thread ne sera jamais exécuté que par un fil. En outre, les tâches sont lancées dans l'ordre dans lequel ils sont soumis, mais cela ne signifie pas nécessairement qu'ils terminaient dans cet ordre.
@Qwerky qui est correct, mais vous pouvez faire des services threadpools (ou exécutants) qui ne contiennent qu'une tâche. Dans ce cas, seule une tâche est en cours d'exécution en même temps, les autres attendent qu'il finisse. Ceci est très utile lors de la mise en œuvre d'un mécanisme FIFO.
L'idée de votre approche est l'une des nombreuses solutions correctes. Traiter avec une interruptionException donne une excellente course sur la manière dont vous devriez utiliser le mécanisme d'interruption . Ce mécanisme est principalement utile lorsque vous êtes longuement des calculs. Une autre chose à garder à l'esprit est qu'il est possible que d'autres bibliothèques gâchent votre mécanisme d'interruption en ne faisant pas ce que le guide dit (ne réinitialisant pas l'état d'interruption quand ils ne l'ont pas traités, etc.).
Notez que votre classe la classe n'est pas du thread-Safe. Vous pouvez arrêter la tâche avant d'enregistrer le Une approche beaucoup plus simple consiste à définir un Une autre chose à regarder est le mécanisme Courrovecthread , qui donnerait une nullpoinpointException.
variable variable exécutant et au lieu d'un tandis que (vrai) boucle faire un tandis que (en cours d'exécution) approche (ceci est cependant beaucoup plus général).
futuretask , car cela dispose déjà d'un mécanisme d'annulation qui utilise le mécanisme d'interruption.
exécutanttorservice.shutdown () et exécutorservice.shutDownNow () doit être utilisé pour arrêter le pool de threads pour sortir gracieusement de l'application. Voir exécutorservice .
Voir la réponse de Qwerky pour mettre fin au fil actuellement exécutant.
Cette réponse est donnée par originale. Mais la fermeture de la piscine de thread est également nécessaire pour sortir gracieusement de l'application.
Vous pouvez l'arrêter en tenant une référence à cet avenir
Future<?> future = exec.submit( new Runnable() {
while (true){
try{
obj.wait();
} catch(InterruptedException e){
System.out.println("interrupted");
return;
}
}
});
future.cancel(true);