Como parar corretamente o Thread em Java?

Preciso de uma solução para parar corretamente o encadeamento em Java.

Eu tenho IndexProcessorclasse que implementa a interface 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 eu tenho ServletContextListenerclasse que inicia e pára o segmento:

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.");
        }
    }
}

Mas quando eu desligo o tomcat, recebo a exceção na minha 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)

Estou usando o JDK 1.6. Então a questão é:

Como posso parar o thread e não lançar nenhuma exceção?

PS: Eu não quero usar o .stop();método porque está obsoleto.

Na IndexProcessorclasse, você precisa definir um sinalizador que informe ao thread que ele precisará finalizar, semelhante à variável runque você usou apenas no escopo da classe.

Quando você deseja interromper o encadeamento, defina esse sinalizador, chame join()o encadeamento e aguarde o término.

Verifique se o sinalizador é seguro para threads usando uma variável volátil ou métodos getter e setter que são sincronizados com a variável que está sendo usada como sinalizador.

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

    }
}

Então em 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.");
        }
    }
}

Usar Thread.interrupt()é uma maneira perfeitamente aceitável de fazer isso. De fato, provavelmente é preferível a uma bandeira, como sugerido acima. O motivo é que, se você estiver em uma chamada de bloqueio interruptível (como Thread.sleepou usando as operações do canal java.nio), poderá realmente romper essas chamadas imediatamente.

Se você usar um sinalizador, precisará aguardar o término da operação de bloqueio e poderá verificar seu sinalizador. Em alguns casos, você precisa fazer isso de qualquer maneira, como usar o padrão InputStream/ OutputStreamque não é interrompível.

Nesse caso, quando um encadeamento é interrompido, ele não interrompe a IO; no entanto, você pode fazer isso rotineiramente com facilidade em seu código (e deve fazê-lo em pontos estratégicos onde pode parar e limpar com segurança)

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

Como eu disse, a principal vantagem Thread.interrupt()é que você pode interromper imediatamente as chamadas interrompíveis, o que não é possível com a abordagem de sinalização.

Resposta simples: você pode interromper um tópico INTERNO de uma das duas maneiras mais comuns:

• O método run atinge uma sub-rotina de retorno.
• O método Run termina e retorna implicitamente.

Você também pode parar os threads EXTERNAMENTE:

• Chamada system.exit(isso mata todo o processo)
• Chame o interrupt()método do objeto de encadeamento *
• Veja se o encadeamento possui um método implementado que parece que funcionaria (como kill()ou stop())

*: A expectativa é que isso pare um encadeamento. No entanto, o que o encadeamento realmente faz quando isso acontece depende inteiramente do que o desenvolvedor escreveu quando criou a implementação do encadeamento.

Um padrão comum que você vê nas implementações de métodos de execução é a while(boolean){}, onde o booleano é geralmente algo chamado isRunning, é uma variável membro de sua classe de encadeamentos, é volátil e geralmente acessível por outros encadeamentos por um método setter, por exemplo kill() { isRunnable=false; }. Essas sub-rotinas são boas porque permitem que o encadeamento libere todos os recursos que ele contém antes de terminar.

Você sempre deve encerrar os threads verificando um sinalizador no run()loop (se houver).

Seu tópico deve ficar assim:

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

Em seguida, você pode encerrar o segmento chamando thread.stopExecuting(). Dessa forma, o encadeamento termina limpo, mas isso leva até 15 segundos (devido ao seu sono). Você ainda pode chamar thread.interrupt () se for realmente urgente - mas a maneira preferida deve sempre estar verificando o sinalizador.

Para evitar esperar 15 segundos, você pode dividir o sono da seguinte maneira:

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

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

Normalmente, um encadeamento é encerrado quando é interrompido. Então, por que não usar o booleano nativo? Tente 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- Como posso matar um tópico? sem usar stop ();

Para sincronizar threads, prefiro usar o CountDownLatchque ajuda os threads a esperar até que o processo esteja sendo concluído. Nesse caso, a classe de trabalhador é configurada com uma CountDownLatchinstância com uma determinada contagem. Uma chamada para o awaitmétodo será bloqueada até que a contagem atual atinja zero devido a invocações do countDownmétodo ou o tempo limite definido seja atingido. Essa abordagem permite interromper um encadeamento instantaneamente sem precisar esperar o tempo de espera especificado:

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 você deseja concluir a execução do outro encadeamento, execute countDown no encadeamento CountDownLatche joinno encadeamento principal:

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.");
        } 
    }
}

Algumas informações adicionais. O sinalizador e a interrupção são sugeridos no 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();
    }
}

Para um encadeamento que aguarda longos períodos (por exemplo, entrada), use Thread.interrupt

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

Como a interrupção não funcionou no Android, usei esse método, funciona perfeitamente:

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

Em algum momento tentarei 1000 vezes no meu 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();}
        }

    }