Comment arrêter correctement le fil en Java?

J'ai besoin d'une solution pour arrêter correctement le thread en Java.

J'ai une IndexProcessorclasse qui implémente l'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;
            }
        }

    }
}

Et j'ai une ServletContextListenerclasse qui démarre et arrête le fil:

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

Mais lorsque j'arrête Tomcat, j'obtiens l'exception dans ma 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)

J'utilise JDK 1.6. La question est donc:

Comment puis-je arrêter le fil et ne lever aucune exception?

PS Je ne veux pas utiliser la .stop();méthode car elle est obsolète.

Dans la IndexProcessorclasse, vous avez besoin d'un moyen de définir un indicateur qui informe le thread qu'il devra se terminer, similaire à la variable runque vous avez utilisée uniquement dans la portée de la classe.

Lorsque vous souhaitez arrêter le thread, vous définissez ce drapeau et appelez join()le thread et attendez qu'il se termine.

Assurez-vous que l'indicateur est thread-safe en utilisant une variable volatile ou en utilisant des méthodes getter et setter qui sont synchronisées avec la variable utilisée comme indicateur.

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

    }
}

Puis dans 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'utilisation Thread.interrupt()est une façon parfaitement acceptable de le faire. En fait, c'est probablement préférable à un drapeau comme suggéré ci-dessus. La raison en est que si vous êtes dans un appel de blocage interruptible (comme Thread.sleepou en utilisant des opérations de canal java.nio), vous pourrez en fait sortir immédiatement.

Si vous utilisez un indicateur, vous devez attendre la fin de l'opération de blocage, puis vous pouvez vérifier votre indicateur. Dans certains cas, vous devez quand même le faire, par exemple en utilisant standard InputStream/ OutputStreamqui ne sont pas interruptibles.

Dans ce cas, lorsqu'un thread est interrompu, il n'interrompra pas l'IO, cependant, vous pouvez facilement le faire régulièrement dans votre code (et vous devez le faire à des points stratégiques où vous pouvez arrêter et nettoyer en toute sécurité)

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

Comme je l'ai dit, le principal avantage Thread.interrupt()est que vous pouvez immédiatement interrompre les appels interruptibles, ce que vous ne pouvez pas faire avec l'approche du drapeau.

Réponse simple: vous pouvez arrêter un thread INTERNE de l'une des deux manières suivantes:

• La méthode run atteint un sous-programme de retour.
• La méthode Run se termine et renvoie implicitement.

Vous pouvez également arrêter les discussions EXTERNE:

• Appelez system.exit(cela tue tout votre processus)
• Appelez la interrupt()méthode de l'objet thread *
• Voir si le thread a une méthode implémentée qui semble fonctionner (comme kill()ou stop())

*: L'attente est que cela est censé arrêter un thread. Cependant, ce que le thread fait réellement lorsque cela se produit dépend entièrement de ce que le développeur a écrit lorsqu'il a créé l'implémentation du thread.

Un modèle courant que vous voyez avec les implémentations de méthode d'exécution est un while(boolean){}, où le booléen est généralement quelque chose nommé isRunning, c'est une variable membre de sa classe de threads, il est volatile, et généralement accessible par d'autres threads par une méthode de définition de sortes, par exemple kill() { isRunnable=false; }. Ces sous-programmes sont agréables car ils permettent au thread de libérer toutes les ressources qu'il détient avant de se terminer.

Vous devez toujours terminer les threads en vérifiant un indicateur 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 terminer le fil en appelant thread.stopExecuting(). De cette façon, le fil est terminé propre, mais cela prend jusqu'à 15 secondes (en raison de votre sommeil). Vous pouvez toujours appeler thread.interrupt () si c'est vraiment urgent - mais la manière préférée devrait toujours être de vérifier l'indicateur.

Pour éviter d'attendre 15 secondes, vous pouvez répartir 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) {
        ...

En règle générale, un thread se termine lorsqu'il est interrompu. Alors, pourquoi ne pas utiliser le booléen natif? Essayez 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- Comment puis-je tuer un fil? sans utiliser stop ();

Pour synchroniser les threads, je préfère utiliser CountDownLatchce qui aide les threads à attendre la fin du processus. Dans ce cas, la classe de travail est configurée avec une CountDownLatchinstance avec un nombre donné. Un appel à la awaitméthode se bloquera jusqu'à ce que le nombre actuel atteigne zéro en raison des appels de la countDownméthode ou que le délai d'expiration soit atteint. Cette approche permet d'interrompre un thread instantanément sans avoir à attendre le temps d'attente spécifié:

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

    }
}

Lorsque vous souhaitez terminer l'exécution de l'autre thread, exécutez countDown sur le CountDownLatchet joinle thread sur 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.");
        } 
    }
}

Quelques informations supplémentaires. Le drapeau et l'interruption sont suggérés dans le document 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();
    }
}

Pour un thread qui attend pendant de longues périodes (par exemple, pour la saisie), utilisez Thread.interrupt

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

Je n'ai pas réussi à faire fonctionner l'interruption sous Android, j'ai donc utilisé cette méthode, elle 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;
 }

Parfois j'essaierai 1000 fois dans mon 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();}
        }

    }