Comment bien arrêter le Thread en Java?

À l'aide de Thread.interrupt() est une très bonne façon de le faire. En fait, il est probablement préférable à un indicateur comme suggéré ci-dessus. La raison en est que si vous êtes dans une interruptable appel de blocage (comme Thread.sleep ou à l'aide de java.nio Canal d'activités), vous aurez en fait être en mesure de sortir de ceux-là.

Si vous utilisez un drapeau, vous devez attendre pour l'opération de blocage à la fin et puis vous pouvez vérifier votre drapeau. Dans certains cas, vous devez le faire de toute façon, comme l'utilisation de la norme InputStream/OutputStream qui ne sont pas interruptable.

Dans ce cas, lorsqu'un thread est interrompu, il n'interrompt pas le IO, cependant, vous pouvez facilement le faire régulièrement dans votre code (et vous devriez le faire à des endroits stratégiques où vous pouvez vous arrêter et de nettoyage)

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

Comme je l'ai dit, le principal avantage de Thread.interrupt() est que vous pouvez immédiatement sortir de interruptable appels, que vous ne pouvez pas faire avec le drapeau de l'approche.

Vous devriez toujours fin des threads en cochant la case dans la run() boucle (le cas échéant).

Votre fil devrait ressembler à ceci:

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

Ensuite, vous pouvez mettre fin à la thread en appelant thread.stopExecuting(). De cette façon, le thread est terminé propre, mais cela prend jusqu'à 15 secondes (en raison de votre sommeil).
Vous pouvez toujours appeler le thread.interrupt() si c'est vraiment urgent, mais la préférence doit toujours être la vérification de l'indicateur.

Pour éviter un temps d'attente de 15 secondes, vous pouvez diviser le sommeil comme ceci:

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

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

Pour la synchronisation des threads, je préfère utiliser CountDownLatch qui aide les threads d'attendre jusqu'à ce que le processus complet exécuté. Dans ce cas, le travailleur de la classe est mis en place avec un CountDownLatch exemple avec un comte. Un appel à await méthode bloquera jusqu'à ce que le compte à rebours atteint zéro, suite aux interpellations de la countDown méthode ou que le délai fixé est atteint. Cette approche permet d'interrompre un thread instantanément sans avoir à attendre pour le temps d'attente indiqué de s'écouler:

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

    }
}

Quand vous voulez à la fin de l'exécution de l'autre fil, exécutez compte à rebours sur le CountDownLatch et join le thread le thread 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.");
        } 
    }
}

Je n'ai pas l'interruption de travail sur Android, j'ai donc utilisé cette méthode, fonctionne parfaitement:

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