Come interrompere correttamente il thread in Java?

Ho bisogno di una soluzione per interrompere correttamente il thread in Java.

Ho una IndexProcessorclasse che implementa l'interfaccia Runnable:

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);

    @Override
    public void run() {
        boolean run = true;
        while (run) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                run = false;
            }
        }

    }
}

E ho una ServletContextListenerclasse che inizia e ferma il thread:

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        thread = new Thread(new IndexProcessor());
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (thread != null) {
            thread.interrupt();
            LOGGER.debug("Thread successfully stopped.");
        }
    }
}

Ma quando chiudo Tomcat, ottengo l'eccezione nella mia classe IndexProcessor:

2012-06-09 17:04:50,671 [Thread-3] ERROR  IndexProcessor Exception
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at lt.ccl.searchengine.processor.IndexProcessor.run(IndexProcessor.java:22)
    at java.lang.Thread.run(Unknown Source)

Sto usando JDK 1.6. Quindi la domanda è:

Come posso interrompere il thread e non generare eccezioni?

PS Non voglio usare il .stop();metodo perché è deprecato.

Nella IndexProcessorclasse hai bisogno di un modo per impostare un flag che informi il thread che dovrà terminare, in modo simile alla variabile runche hai usato solo nell'ambito della classe.

Quando si desidera interrompere il thread, impostare questo flag e chiamare join()il thread e attendere che termini.

Assicurarsi che il flag sia sicuro per il thread utilizzando una variabile volatile o utilizzando i metodi getter e setter sincronizzati con la variabile utilizzata come flag.

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);
    private volatile boolean running = true;

    public void terminate() {
        running = false;
    }

    @Override
    public void run() {
        while (running) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                running = false;
            }
        }

    }
}

Quindi in SearchEngineContextListener:

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;
    private IndexProcessor runnable = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        runnable = new IndexProcessor();
        thread = new Thread(runnable);
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (thread != null) {
            runnable.terminate();
            thread.join();
            LOGGER.debug("Thread successfully stopped.");
        }
    }
}

L'utilizzo Thread.interrupt()è un modo perfettamente accettabile per farlo. In effetti, è probabilmente preferibile una bandiera come suggerito sopra. Il motivo è che se stai effettuando una chiamata di blocco interrompibile (come Thread.sleepo usando le operazioni del canale java.nio), sarai effettivamente in grado di uscire da quelli immediatamente.

Se si utilizza un flag, è necessario attendere il completamento dell'operazione di blocco e quindi è possibile controllare il flag. In alcuni casi è necessario farlo comunque, ad esempio utilizzando standard InputStream/ OutputStreamche non sono interrompibili.

In tal caso, quando un thread viene interrotto, non interromperà l'IO, tuttavia, puoi facilmente farlo regolarmente nel tuo codice (e dovresti farlo in punti strategici in cui puoi fermarti e ripulire in modo sicuro)

if (Thread.currentThread().isInterrupted()) {
  // cleanup and stop execution
  // for example a break in a loop
}

Come ho detto, il vantaggio principale Thread.interrupt()è che puoi immediatamente uscire da chiamate interrompibili, cosa che non puoi fare con l'approccio flag.

Risposta semplice: puoi interrompere una discussione INTERAMENTE in uno dei due modi più comuni:

• Il metodo run esegue una subroutine di ritorno.
• Il metodo di esecuzione termina e restituisce implicitamente.

Puoi anche interrompere i thread ESTERNI:

• Chiama system.exit(questo uccide l'intero processo)
• Chiama il interrupt()metodo dell'oggetto thread *
• Verifica se il thread ha un metodo implementato che sembra funzionare (come kill()o stop())

*: L'aspettativa è che questo dovrebbe fermare un thread. Tuttavia, ciò che il thread effettivamente fa quando ciò accade dipende interamente da ciò che lo sviluppatore ha scritto quando ha creato l'implementazione del thread.

Un modello comune che vedi con le implementazioni del metodo run è a while(boolean){}, in cui il booleano è in genere un nome isRunning, è una variabile membro della sua classe thread, è volatile e in genere accessibile da altri thread con un metodo setter di sorta, ad es kill() { isRunnable=false; }. Queste subroutine sono utili perché consentono al thread di rilasciare tutte le risorse in suo possesso prima di terminare.

Dovresti sempre terminare i thread controllando un flag nel run()loop (se presente).

Il tuo thread dovrebbe apparire così:

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);
    private volatile boolean execute;

    @Override
    public void run() {
        this.execute = true;
        while (this.execute) {
            try {
                LOGGER.debug("Sleeping...");
                Thread.sleep((long) 15000);

                LOGGER.debug("Processing");
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
                this.execute = false;
            }
        }
    }

    public void stopExecuting() {
        this.execute = false;
    }
}

Quindi puoi terminare il thread chiamando thread.stopExecuting(). In questo modo il thread è finito pulito, ma ciò richiede fino a 15 secondi (a causa del sonno). Puoi ancora chiamare thread.interrupt () se è davvero urgente, ma il modo preferito dovrebbe sempre controllare la bandiera.

Per evitare l'attesa di 15 secondi, puoi dividere il sonno in questo modo:

        ...
        try {
            LOGGER.debug("Sleeping...");
            for (int i = 0; (i < 150) && this.execute; i++) {
                Thread.sleep((long) 100);
            }

            LOGGER.debug("Processing");
        } catch (InterruptedException e) {
        ...

In genere, un thread viene terminato quando viene interrotto. Quindi, perché non usare il booleano nativo? Prova isInterrupted ():

Thread t = new Thread(new Runnable(){
        @Override
        public void run() {
            while(!Thread.currentThread().isInterrupted()){
                // do stuff         
            }   
        }});
    t.start();

    // Sleep a second, and then interrupt
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {}
    t.interrupt();

ref- Come posso uccidere un thread? senza usare stop ();

Per sincronizzare i thread preferisco usare CountDownLatchquale aiuta i thread ad attendere fino al completamento del processo. In questo caso, la classe worker è impostata con CountDownLatchun'istanza con un determinato conteggio. Una chiamata al awaitmetodo verrà bloccata fino a quando il conteggio corrente non raggiunge lo zero a causa di invocazioni del countDownmetodo o al raggiungimento del timeout impostato. Questo approccio consente di interrompere immediatamente un thread senza dover attendere che trascorra il tempo di attesa specificato:

public class IndexProcessor implements Runnable {

    private static final Logger LOGGER = LoggerFactory.getLogger(IndexProcessor.class);

    private final CountDownLatch countdownlatch;
    public IndexProcessor(CountDownLatch countdownlatch) {
        this.countdownlatch = countdownlatch;
    }


    public void run() {
        try {
            while (!countdownlatch.await(15000, TimeUnit.MILLISECONDS)) {
                LOGGER.debug("Processing...");
            }
        } catch (InterruptedException e) {
            LOGGER.error("Exception", e);
            run = false;
        }

    }
}

Quando vuoi terminare l'esecuzione dell'altro thread, esegui countDown su CountDownLatche joinil thread sul thread principale:

public class SearchEngineContextListener implements ServletContextListener {

    private static final Logger LOGGER = LoggerFactory.getLogger(SearchEngineContextListener.class);

    private Thread thread = null;
    private IndexProcessor runnable = null;
    private CountDownLatch countdownLatch = null;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        countdownLatch = new CountDownLatch(1);
        Thread thread = new Thread(new IndexProcessor(countdownLatch));
        LOGGER.debug("Starting thread: " + thread);
        thread.start();
        LOGGER.debug("Background process successfully started.");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        LOGGER.debug("Stopping thread: " + thread);
        if (countdownLatch != null) 
        {
            countdownLatch.countDown();
        } 
        if (thread != null) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                LOGGER.error("Exception", e);
            }
            LOGGER.debug("Thread successfully stopped.");
        } 
    }
}

Alcune informazioni supplementari. Sia il flag che l'interrupt sono suggeriti nel documento Java.

https://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html

private volatile Thread blinker;

public void stop() {
    blinker = null;
}

public void run() {
    Thread thisThread = Thread.currentThread();
    while (blinker == thisThread) {
        try {
            Thread.sleep(interval);
        } catch (InterruptedException e){
        }
        repaint();
    }
}

Per un thread che attende per lunghi periodi (ad es. Per input), utilizzare Thread.interrupt

public void stop() {
     Thread moribund = waiter;
      waiter = null;
      moribund.interrupt();
 }

Non ho interrotto il funzionamento in Android, quindi ho usato questo metodo, funziona perfettamente:

boolean shouldCheckUpdates = true;

private void startupCheckForUpdatesEveryFewSeconds() {
    threadCheckChat = new Thread(new CheckUpdates());
    threadCheckChat.start();
}

private class CheckUpdates implements Runnable{
    public void run() {
        while (shouldCheckUpdates){
            System.out.println("Do your thing here");
        }
    }
}

 public void stop(){
        shouldCheckUpdates = false;
 }

A volte proverò 1000 volte nel mio onDestroy () / contextDestroyed ()

      @Override
    protected void onDestroy() {
        boolean retry = true;
        int counter = 0;
        while(retry && counter<1000)
        {
            counter++;
            try{thread.setRunnung(false);
                thread.join();
                retry = false;
                thread = null; //garbage can coll
            }catch(InterruptedException e){e.printStackTrace();}
        }

    }