Meilleure façon d'identifier et d'éliminer le thread verrouillé dans Java

Question

Je dois appeler un module de fonction tiers sur un nouveau thread. D'après ce que j'ai vu, l'appel se termine rapidement si tout s'est bien passé ou il se bloque à jamais pour enfermer le fil. Quelle est une bonne façon de démarrer le thread et faire l'appel et attendre quelques secondes et si le thread est toujours en vie, puis en supposant qu'il est verrouillé, tuer (ou arrêter ou abandonner) le fil sans utiliser de méthodes obsolètes.

J'ai quelque chose comme ça pour l'instant, mais je ne suis pas sûr que ce soit la meilleure façon de le faire et je veux éviter d'appeler Thread.stop() comme c'est obsolète. Merci.

private void foo() throws Exception 
{ 
     Runnable runnable = new Runnable() 
     { 

      @Override 
      public void run() 
      { 
        // stuff that could potentially lock up the thread. 
      } 
     }; 
     Thread thread; 
     thread = new Thread(runnable); 
     thread.start(); 
     thread.join(3500); 
     if (thread.isAlive()) 
     { 
      thread.stop(); 
      throw new Exception(); 
     } 

} 

Answer 1

public void stop() { 
     if (thread != null) { 
      thread.interrupt(); 
     } 
    } 

See this link sur Comment arrêter un fil, il couvre bien le sujet

Answer 2

je regarderais dans le cadre java.util.concurrentExecutor et plus précisément l'interface Future<T>. avec ceux-ci vous êtes quelque peu extrait des caprices de java.lang.Thread, et vous obtenez un bon découplage de ce que sont les tâches de leur exécution (que ce soit sur un thread séparé, si le thread provient d'un pool ou est instancié sur le voler, etc.)

Une instance future, au moins, vous donne les méthodeset isCancelled.

La sous-interface ExecutorService (sous-interface de Executor) vous permet de fermer toutes les tâches en encours. Ou consultez la méthode ExecutorService.awaitTermination(long timeout, TimeUnit unit)

private void foo() throws Exception 
{ 
     ExecutorService es = Executors.newFixedThreadPool(1); 

     Runnable runnable = new Runnable() 
     { 

      @Override 
      public void run() 
      { 
        // stuff that could potentially lock up the thread. 
      } 
     }; 

     Future result = es.submit(runnable); 

     es.awaitTermination(30, TimeUnit.SECONDS); 

     if (!result.isDone()){ 
      es.shutdownNow(); 
     } 

} 

Answer 3

Il n'y a aucun moyen de faire ce que vous voulez (sans conditions). Par exemple, si l'stuff that could potentially lock up the thread. ressemble à ceci, il n'y a pas moyen de l'arrêter, jamais à court de System.exit():

public void badStuff() { 
while (true) { 
    try { 
    wait(); 
    } 
    catch (InterruptedException irex) { 
    } 
} 
} 

Lorsque votre application est bloqué, exécutez jstack (ou utilisez le débogueur). Essayez de comprendre ce qui colle la fonction et la réparer.