Jak poprawnie zatrzymać wątek w Javie?

Potrzebuję rozwiązania, aby poprawnie zatrzymać wątek w Javie.

Mam IndexProcessorklasę, która implementuje interfejs 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;
            }
        }

    }
}

I mam ServletContextListenerklasę, która rozpoczyna i zatrzymuje wątek:

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

Ale kiedy zamykam tomcat, otrzymuję wyjątek w mojej klasie 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)

Używam JDK 1.6. Pytanie brzmi:

Jak mogę zatrzymać wątek i nie zgłaszać żadnych wyjątków?

PS Nie chcę używać .stop();metody, ponieważ jest przestarzała.

W IndexProcessorklasie potrzebujesz sposobu ustawienia flagi, która informuje wątek, że będzie musiał zakończyć działanie, podobnie jak zmiennarun , której użyłeś tylko w zakresie klasy.

Kiedy chcesz zatrzymać wątek, ustaw tę flagę, wzywaj join()wątek i poczekaj, aż zakończy się.

Upewnij się, że flaga jest bezpieczna dla wątków, używając zmiennej lotnej lub metod pobierających i ustawiających, które są zsynchronizowane ze zmienną używaną jako flaga.

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

    }
}

Następnie w 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.");
        }
    }
}

Używanie Thread.interrupt()jest całkowicie akceptowalnym sposobem na zrobienie tego. W rzeczywistości jest to prawdopodobnie lepsze niż flaga, jak sugerowano powyżej. Thread.sleepWynika to z faktu, że jeśli prowadzisz przerywaną rozmowę blokującą (np. Lub korzystasz z operacji na kanale java.nio), będziesz w stanie od razu oderwać się od nich.

Jeśli używasz flagi, musisz poczekać na zakończenie operacji blokowania, a następnie możesz sprawdzić swoją flagę. W niektórych przypadkach i tak musisz to zrobić, na przykład używając standardowego InputStream/ OutputStreamktóre nie są przerywane.

W takim przypadku, gdy wątek zostanie przerwany, nie spowoduje to przerwania operacji we / wy, jednak można to łatwo zrobić rutynowo w kodzie (i należy to zrobić w strategicznych punktach, w których można bezpiecznie zatrzymać i wyczyścić)

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

Jak powiedziałem, główną zaletą Thread.interrupt()jest to, że możesz natychmiast zerwać z przerwanych połączeń, czego nie można zrobić przy podejściu flagowym.

Prosta odpowiedź: możesz zatrzymać wątek WEWNĘTRZNIE na jeden z dwóch typowych sposobów:

• Metoda uruchamiania trafia w podprogram powrotu.
• Metoda Run kończy się i zwraca niejawnie.

Możesz także zatrzymać wątki ZEWNĘTRZNIE:

• Zadzwoń system.exit(to zabija cały proces)
• Wywołaj interrupt()metodę obiektu wątku *
• Sprawdź, czy wątek ma zaimplementowaną metodę, która brzmi tak, jakby działał (jak kill()lub stop())

*: Oczekuje się, że ma to zatrzymać wątek. Jednak to, co faktycznie robi wątek, gdy tak się dzieje, zależy wyłącznie od tego, co napisał programista, gdy utworzyli implementację wątku.

Typowy wzorzec, który widzisz w implementacjach metod uruchamiania, to taki while(boolean){}, gdzie boolean ma zwykle coś o nazwie isRunning, jest zmienną składową swojej klasy wątku, jest zmienny i zazwyczaj dostępny dla innych wątków za pomocą metod ustawiających, np kill() { isRunnable=false; }. Te podprogramy są fajne, ponieważ pozwalają wątkowi zwolnić wszystkie posiadane zasoby przed zakończeniem.

Zawsze powinieneś kończyć wątki, sprawdzając flagę w run() pętli (jeśli istnieje).

Twój wątek powinien wyglądać następująco:

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

Następnie możesz zakończyć wątek, dzwoniąc thread.stopExecuting() . W ten sposób nić zostaje zakończona czysto, ale zajmuje to do 15 sekund (z powodu twojego snu). Nadal możesz wywołać thread.interrupt (), jeśli jest to naprawdę pilne - ale preferowanym sposobem powinno być zawsze sprawdzanie flagi.

Aby uniknąć czekania przez 15 sekund, możesz podzielić sen w następujący sposób:

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

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

Zazwyczaj wątek jest przerywany, gdy zostanie przerwany. Dlaczego więc nie użyć natywnej wartości logicznej? Spróbuj 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- Jak mogę zabić wątek? bez użycia stop ();

Do synchronizacji wątków wolę używać, CountDownLatchktóry pomaga wątkom czekać na zakończenie procesu. W takim przypadku klasa procesu roboczego jest konfigurowana z CountDownLatchinstancją o podanej liczbie. Wywołanie awaitmetody będzie blokowane, dopóki bieżąca liczba nie osiągnie zera z powodu wywołania countDownmetody lub osiągnięcia limitu czasu. Takie podejście umożliwia natychmiastowe przerwanie wątku bez konieczności oczekiwania na upływ określonego czasu oczekiwania:

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

    }
}

Gdy chcesz zakończyć wykonanie innego wątku, wykonać na odliczanie CountDownLatchi joingwint do głównego wątku:

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

Niektóre dodatkowe informacje. Zarówno flaga, jak i przerwanie są sugerowane w dokumencie 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();
    }
}

W przypadku wątku, który czeka przez długi czas (np. Na dane wejściowe), użyj Thread.interrupt

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

Nie udało mi się przerwać pracy w Androidzie, więc użyłem tej metody, działa idealnie:

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

Kiedyś spróbuję 1000 razy w mojej funkcji 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();}
        }

    }