Miglior modo per identificare e smaltire filo bloccato in java

Question

devo chiamare un modulo funzionale 3rd party su un nuovo thread. Da quello che ho visto, la chiamata viene completata sia rapidamente se tutto è andato bene o appende appena per sempre bloccare il filo. Che cosa è un buon modo per iniziare la discussione ed effettuare la chiamata e attendere alcuni secondi e se il filo è ancora vivo, quindi ammesso che sia rinchiuso, uccidere (o di arresto o abbandonare) il filo senza l'uso di metodi deprecati.

Ho qualcosa di simile per ora, ma non sono sicuro se questo è il modo migliore per farlo e voglio evitare di chiamare Thread.stop () come è deprecato. Grazie.

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();
        }
    }

Vedi questo link su come fermare un thread, che copre bene il soggetto

Answer 2

Non v'è alcun modo per fare ciò che si vuole (senza condizioni). Per esempio, se gli sguardi stuff that could potentially lock up the thread. come questo, non c'è modo di fermarlo, mai a corto di System.exit ():

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

Quando la tua applicazione si blocca, eseguire jstack (o usare il debugger). Cercate di capire cosa sporge la funzione e risolvere il problema.

Answer 3

I apparirebbe nel quadro java.util.concurrent Executor e in particolare l'interfaccia Future<T>. con questi si sono astratte in qualche modo dai capricci del java.lang.Thread, e si ottiene una buona disaccoppiamento di ciò che i compiti sono da come vengono eseguiti (sia su un thread separato, se il thread viene da una piscina o viene creata un'istanza sulla fly, ecc.)

Un esempio futuro, almeno, vi dà isDone e metodi isCancelled.

Il ExecutorService (subinterface di Executor) vi dà alcuni mezzi di spegnere qualsiasi attività impieghi. O controllare il metodo 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();
        }

}