Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Thread: uruchamianie, oczekiwanie na zakończenie i przerywanie

Twórz wątki platformowe z zadania Runnable, uruchamiaj je przez start(), odczytuj wyniki po join() i obsługuj żądania anulowania bez utraty informacji o przerwaniu.

Wersja: Java SE 21

Składnia

new Thread(task);             // task: Runnable
new Thread(task, name);       // name: String
worker.start();               // void
worker.join();                // void; throws InterruptedException
worker.join(millis);          // long; same return and checked exception
worker.join(millis, nanos);   // long, int; same return and checked exception
worker.join(duration);        // java.time.Duration; boolean; throws InterruptedException
Thread.currentThread();       // static; returns Thread
worker.getName();             // returns String
worker.interrupt();           // request interruption of worker
Thread.currentThread().interrupt(); // set the calling thread's interrupt status

W Java SE 21 oba konstruktory klasy java.lang.Thread tworzą jeszcze nieuruchomiony wątek platformowy, nie wirtualny. Thread(Runnable) nadaje nazwę automatycznie; Thread(Runnable,String) przyjmuje nazwę od wywołującego. Statyczne Thread.currentThread() zwraca aktualnie wykonujący się wątek, a metoda instancji getName() zwraca jego nazwę. Nazwa jest etykietą, nie unikatowym identyfikatorem.

worker.start() zleca wykonanie zadania w nowym wątku. Bezpośrednie worker.run() wykonuje zadanie w wątku wywołującym. Ponowne start() kończy się IllegalThreadStateException, nawet po zakończeniu wątku. Działania sprzed start() są widoczne dla uruchomionego wątku dzięki relacji happens-before. Samo start() nie ustala kolejności wykonywania zadań.

worker.join() wstrzymuje wątek wywołujący do zakończenia uruchomionego wątku worker; dla nieuruchomionego wraca od razu. Po normalnym powrocie z join() dla uruchomionego wątku jego zapisy są widoczne dla wywołującego. Poczekaj na wszystkich producentów wyników: nie usuwa to wyścigów między nimi ani nie dowodzi sukcesu zadań. Warianty join(long) i join(long,int) mogą wrócić po upływie limitu; same zera oznaczają brak limitu. join(Duration) zwraca informację o zakończeniu i dla nieuruchomionego wątku zgłasza IllegalThreadStateException.

worker.interrupt() sygnalizuje przerwanie wątkowi worker, ale nie wymusza jego zatrzymania. Gdy join() lub await() zgłosi InterruptedException, flaga przerwania wątku wywołującego jest wyczyszczona. Przekaż wyjątek dalej albo, jeśli nie możesz, posprzątaj zasoby, przywróć flagę przez Thread.currentThread().interrupt() i zakończ ścieżkę anulowania bez zgłaszania sukcesu. isInterrupted() odczytuje flagę bez czyszczenia; statyczne Thread.interrupted() odczytuje i czyści flagę bieżącego wątku. Nie polegaj na przerywaniu nieaktywnego wątku; w Java SE 21 menedżer bezpieczeństwa może zabronić przerwania innego wątku.

Przykłady

import java.util.concurrent.CountDownLatch;

public class ThreadMethodsDemo {
    public static void main(String[] args) throws InterruptedException {
        var gate = new CountDownLatch(1);
        var observations = new String[2];

        Thread compute = new Thread(() -> observations[0] = "sum=" + (20 + 22));
        Thread cancellable = new Thread(() -> {
            Thread self = Thread.currentThread();
            try {
                gate.await();
            } catch (InterruptedException e) {
                self.interrupt();
                observations[1] = self.getName() + ": cancelled; interrupted="
                        + self.isInterrupted();
                return;
            }
        }, "cancellable");

        compute.start();
        cancellable.start();
        cancellable.interrupt();
        compute.join();
        cancellable.join();

        System.out.println(observations[0]);
        System.out.println(observations[1]);
    }
}

Wynik

sum=42
cancellable: cancelled; interrupted=true

Pierwszy wątek zapisuje sumę, a nazwany wątek zapisuje informację o anulowaniu. Zatrzask pozostaje zamknięty: `await()` reaguje na przerwanie niezależnie od tego, czy nastąpiło przed oczekiwaniem, czy w jego trakcie. Tylko `main` wypisuje dane, po obu `join()`, więc kolejność wierszy nie zależy od planisty.

Powiązane lekcje

  • Java · Lekcja 25 · Zaawansowany · Wersja: 2
  • Java · Lekcja 28 · Zaawansowany · Wersja: 2
  • Java · Lekcja 30 · Zaawansowany · Wersja: 2
  • Java · Lekcja 33 · Zaawansowany · Wersja: 2
  • Java · Lekcja 34 · Zaawansowany · Wersja: 2
  • Java · Lekcja 35 · Zaawansowany · Wersja: 2
  • Java · Lekcja 36 · Zaawansowany · Wersja: 2
  • Java · Lekcja 37 · Zaawansowany · Wersja: 2
  • Java · Lekcja 38 · Zaawansowany · Wersja: 2

Źródła