Jak poprawnie zatrzymać wątek w Javie?

Używanie Thread.interrupt() jest całkowicie akceptowalnym sposobem na to. W rzeczywistości jest to prawdopodobnie preferowane do flagi, jak sugerowano powyżej. Powodem jest to, że jeśli jesteś w przerwanym wywołaniu blokującym (jak Thread.sleep lub używasz Javy.NIO Channel operations), będziesz w stanie od razu się z nich wyrwać.

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

W takim przypadku, gdy wątek zostanie przerwany, nie spowoduje przerwania IO, jednak możesz to zrobić rutynowo w kodzie (i powinieneś to zrobić w strategicznych punktach, gdzie możesz bezpiecznie zatrzymać i oczyścić)

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

Jak mówiłem, główną zaletą Thread.interrupt() jest to, że możesz natychmiast przerwać przerwane połączenia, czego nie możesz zrobić z podejściem flagowym.

Prosta odpowiedź: Możesz zatrzymać wątek wewnętrznie na jeden z dwóch powszechnych sposobów:

• metoda run uderza w podprogram powrotny.
• metoda Run kończy działanie i zwraca ją bezwarunkowo.

Możesz także zatrzymać wątki zewnętrznie:

• wywołanie system.exit (to zabija cały proces)
• wywołanie metody obiektu wątku interrupt() *
• sprawdź, czy wątek ma zaimplementowaną metodę, która brzmi jakby działała (jak kill() lub stop())

*: Oczekuje się, że to ma zatrzymać wątek. Jednak to, co faktycznie robi wątek, gdy tak się dzieje, zależy całkowicie od tego, co napisał deweloper, gdy stworzył implementację wątku.

Często spotykanym wzorcem w implementacjach run method jest while(boolean){}, gdzie wartość logiczna jest zwykle czymś o nazwie isRunning, jest zmienną członkowską klasy thread, jest zmienna zmienna zmienna zmienna jest zmienna zmienna jest zmienna zmienna jest zmienna zmienna jest zmienna zmienna jest zmienna zmienna jest Podprogramy te są ładne, ponieważ pozwalają wątkowi zwolnić wszelkie zasoby, które posiada przed zakończeniem.

Należy zawsze kończyć wątki, sprawdzając flagę w pętli run() (jeśli istnieje).

Twój wątek powinien wyglądać tak:

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 wywołując thread.stopExecuting(). W ten sposób wątek jest zakończony czysto, ale trwa to do 15 sekund (ze względu na sen). Nadal możesz zadzwonić do thread.interrupt (), jeśli jest to naprawdę pilne - ale preferowanym sposobem zawsze powinno być sprawdzenie flagi.

Aby uniknąć oczekiwania na 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) {
        ...

Do synchronizacji wątków wolę używać CountDownLatch, która pomaga wątkom czekać do zakończenia procesu. W tym przypadku Klasa worker jest skonfigurowana z instancją CountDownLatch z podaną liczbą. Wywołanie metody await będzie blokowane, dopóki bieżąca liczba nie osiągnie zera z powodu wywołania metody countDown lub osiągnięcia limitu czasu. Takie podejście pozwala na natychmiastowe przerwanie wątku bez konieczności oczekiwania na określony czas 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;
        }

    }
}

Kiedy aby zakończyć wykonywanie drugiego wątku, wykonaj countDown na CountDownLatch i join wątku 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.");
        } 
    }
}

Jeśli używamy JDK 1.0, możemy wywołać przestarzałą metodę wątku stop (), aby ją zakończyć. Użycie stop() jest niezwykle niebezpieczne, ponieważ zabije Twój wątek, nawet jeśli jest w środku czegoś ważnego. Nie ma sposobu, aby się chronić, więc jeśli zauważysz kod, który używa stop (), powinieneś marszczyć brwi.

Jak zamknąć wątek?

W Javie uruchamianie wątków jest łatwe, ale ich wyłączenie wymaga dużo uwagi i wysiłku.

Oto Jak to jest zaprojektowany w Javie. W każdym wątku java znajduje się flaga o nazwie Interrupt status flag, którą możemy ustawić z zewnątrz, tj. wątek nadrzędny lub główny. Wątek może to sprawdzić od czasu do czasu i wstrzymać jego wykonanie. Dobrowolnie..!! Oto jak:

Thread loop = new Thread(new Runnable() {
@Override
public void run() {
  while (true) {
    if (Thread.interrupted()) {
      break;
    }
    // Continue to do nothing
  }
}}); loop.start(); loop.interrupt();

Źródło: Jak zatrzymać wątek w Javie / wielowątkowość

Jakieś 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();
    }
}

Dla wątku, który czeka przez długi czas (np. na wejście), użyj Thread.interrupt

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

Nie dostałem przerwania do 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;
 }