La meilleure façon d'identifier et d'éliminer fil verrouillé en java

Question

Je dois appeler un module 3 fonction du parti sur un nouveau thread. D'après ce que j'ai vu, l'appel se termine soit rapidement si tout allait bien ou il juste pour toujours verrouillage bloque le fil. Ce qui est une bonne façon de commencer le fil et faire l'appel et attendre quelques secondes et si le fil est toujours en vie, puis en supposant qu'il est enfermé, tuer (ou un arrêt ou abandonner) le fil sans utiliser de méthodes dépréciées.

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 il est dépréciée. 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();
        }
    }

Voir ce lien sur Comment arrêter un fil, il couvre bien le sujet

Answer 2

Il n'y a aucun moyen de faire ce que vous voulez (sans conditions). Par exemple, si les regards stuff that could potentially lock up the thread. comme celui-ci, 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 le fixer.

Answer 3

Je regarderait dans le cadre de java.util.concurrent Executor et plus précisément l'interface Future<T>. avec ces vous Abstraite quelque peu des caprices de java.lang.Thread, et vous obtenez un bon découplage de ce que les tâches sont de la façon dont ils sont exécutés (que ce soit sur un thread séparé, que le fil provient d'une piscine ou est instancié sur la mouche, etc.)

Une instance avenir, au moins, vous donne isDone et les méthodes de isCancelled.

Le ExecutorService (subinterface de Executor) vous donne des moyens d'arrêter toutes les tâches 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();
        }

}