Fil.stop () - obsolète
Pourquoi Thread.stop() est-il obsolète en Java? Sur leur site, je vois ce qui suit:
Pourquoi
Thread.stopest-il obsolète?Parce que c'est intrinsèquement dangereux. L'arrêt d'un thread lui permet de déverrouiller tous les moniteurs qu'il a verrouillés. (Les moniteurs sont déverrouillés lorsque l'exception
ThreadDeathse propage dans la pile.) Si l'un des objets précédemment protégés par ces moniteurs était dans un état incohérent, d'autres threads peuvent maintenant afficher ces objets dans un état incohérent. De tels objets sont dit d'être endommagé. Lorsque les threads fonctionnent sur des objets endommagés, un comportement arbitraire peut en résulter. Ce comportement peut être subtil et difficile à détecter, ou il peut être prononcé. Contrairement à d'autres exceptions non cochées,ThreadDeathtue silencieusement les threads; ainsi, l'utilisateur n'a aucun avertissement que son programme peut être corrompu. La corruption peut se manifester à tout moment après que les dommages réels se produisent, même des heures ou des jours à l'avenir.
Je ne comprends pas ce qu'ils veulent dire par"moniteurs". Peu importe, mon la question Est Si Thread.stop() ne devrait pas être appelé alors comment un thread Java devrait-il être arrêté?
4 réponses
Vous avez demandé:
Ma question Est de savoir s'il n'y a aucun moyen d'arrêter un thread en Java alors comment arrêter un thread?
La réponse: en Java, il n'y a pas de moyen propre, rapide ou fiable d'arrêter un thread.
La terminaison du Thread n'est pas aussi simple. Un thread en cours d'exécution, souvent appelé par de nombreux écrivains comme un processus léger, a sa propre pile et est le maître de son propre destin (les démons sont bien). Il peut posséder des fichiers et des sockets. Il peut contenir des serrures. Abrupt La terminaison n'est pas toujours facile: des conséquences imprévisibles peuvent survenir si le thread est au milieu de l'écriture dans un fichier et est tué avant de pouvoir terminer l'écriture. Ou qu'en est-il des serrures de moniteur tenues par le fil quand il est tiré dans la tête?
Au Lieu de cela, les Threads s'appuient sur un mécanisme coopératif appeléInterruption . Cela signifie que les Threads ne peuvent que signaler à d'autres threads de s'arrêter, pas les forcer à s'arrêter.
Pour arrêter les threads Java, nous comptons sur un mécanisme coopératif appelé Interruption. Le concept est très simple. Pour arrêter un thread, tout ce que nous pouvons faire est de lui délivrer un signal, alias l'interrompre, demandant que le thread s'arrête à la prochaine opportunité disponible. C'est tout. On ne sait pas ce que le thread récepteur pourrait faire avec le signal: il peut même ne pas prendre la peine de vérifier le signal; ou pire encore l'ignorer.
Source: http://10kloc.wordpress.com/2013/03/03/java-multithreading-steeplechase-stopping-threads/
La bonne façon est d'utiliser une jointure. Au lieu d'arrêter prématurément l'exécution d'un thread, rejoignez va attendre que le thread pour terminer l'exécution avant de passer à l'instruction suivante.
Thread exampleThread = new Thread(){
public void run(){
try {
Thread.sleep(2000);
} catch (InterruptedException ex) {
//handle the exception
}
}
};
exampleThread.start();
exampleThread.join();
Voici exampleThread.join() attendra que exampleThread soit terminé avant de passer à l'instruction suivante. Cependant, il incombe au programmeur de s'assurer que le thread termine l'exécution. En substance il n'y a aucun moyen d'arrêter un fil mais si vous le concevez correctement vous ne devriez pas faut arrêter le fil.
Lorsque votre thread gère correctement les interruptions, il devrait être possible de le terminer instantanément avec l'utilisation de l'interface ExecutorService. Selon la documentation Oracle, ExecutorService.shutdownNow() méthode, tente d'arrêter toutes les tâches en cours d'exécution sans attendre leur résiliation. Il n'y a cependant aucune garantie au-delà des tentatives de tous les efforts pour les arrêter. Voici un exemple de code:
class MyThread implements Runnable{
@Override
public void run() {
for (int i = 1; i < 10000000; i++)
try {
System.out.println(i + " ThreadID: " + Thread.currentThread().getId());
if (Thread.interrupted())
throw new InterruptedException();
} catch (InterruptedException e) {
return;
}
}
}
ExecutorService executor = Executors.newFixedThreadPool(3);
executor.submit(new MyThread());
executor.submit(new MyThread());
executor.submit(new MyThread());
executor.shutdownNow();
Sans terminaison, chaque thread doit imprimer un message sur la console 10000000 fois. executor.shutdownNow() Méthode arrête instantanément tous trois fils.
À Partir de https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html:
La plupart des utilisations de stop doivent être remplacées par du code qui modifie simplement une variable pour indiquer que le thread cible doit cesser de s'exécuter. Le thread cible doit vérifier cette variable régulièrement et revenir de sa méthode d'exécution de manière ordonnée si la variable indique qu'elle doit arrêter de s'exécuter. Pour assurer une communication rapide de la demande d'arrêt, la variable doit être volatile (ou access à la variable doit être synchronisé ).