База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Thread: стартиране, изчакване на приключването и прекъсване

Създавайте платформени нишки от задачи Runnable, стартирайте ги само веднъж, четете резултатите след join() и запазвайте флага за прекъсване при кооперативно отменяне.

Версия: Java SE 21

Синтаксис

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

В Java SE 21 двата конструктора на java.lang.Thread създават все още нестартирана платформена нишка, а не виртуална нишка. Thread(Runnable) генерира име, а Thread(Runnable,String) използва подаденото име. Статичният метод Thread.currentThread() връща нишката, която изпълнява извикването. Методът на екземпляра getName() връща нейното име, което е етикет, а не уникален идентификатор.

worker.start() планира изпълнението на задачата в новата нишка. Прякото извикване на worker.run() изпълнява задачата в извикващата нишка. Повторно извикване на start() хвърля IllegalThreadStateException дори след приключване на нишката. Връзката happens-before прави действията преди start() видими за стартираната нишка. Редът на стартиране не определя реда на изпълнение.

worker.join() кара извикващата нишка да чака приключването на стартираната работна нишка. Ако тя не е стартирана, методът се връща незабавно. След нормално връщане от join() за стартирана нишка нейните записи са видими за извикващата нишка. Изчакайте всички нишки, които създават резултати, преди да ги прочетете. Това нито отстранява състезанията при достъп до данни между нишките, нито доказва, че задачите са успели. join(long) и join(long,int) могат да се върнат при изтичане на срока; ако всички аргументи са нули, няма ограничение във времето. join(Duration) показва дали нишката е приключила и хвърля IllegalThreadStateException за нестартирана нишка.

worker.interrupt() изпраща сигнал за прекъсване, но не спира нишката принудително. Когато join() или await() хвърли InterruptedException, флагът за прекъсване на извикващата нишка се изчиства. Предайте изключението нагоре, ако е възможно; иначе освободете ресурсите, възстановете флага чрез Thread.currentThread().interrupt() и приключете обработката на отмяната, без да отчитате успех. isInterrupted() чете флага, без да го изчиства; статичният Thread.interrupted() чете и изчиства флага на текущата нишка. Не разчитайте, че прекъсването ще има ефект върху нишка, която не е жива. В Java SE 21 мениджърът на сигурността може да забрани прекъсването на друга нишка.

Примери

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

Резултат

sum=42
cancellable: cancelled; interrupted=true

Първата нишка записва сума, а именуваната нишка отбелязва отмяната. Преградата остава затворена, затова `await()` реагира на прекъсването както преди, така и по време на изчакването. Само `main` извежда резултатите след двете извиквания на `join()`, така че редът на редовете не зависи от планирането.

Свързани уроци

  • Java · Урок 25 · Напреднало · Версия: 2
  • Java · Урок 28 · Напреднало · Версия: 2
  • Java · Урок 30 · Напреднало · Версия: 2
  • Java · Урок 33 · Напреднало · Версия: 2
  • Java · Урок 34 · Напреднало · Версия: 2
  • Java · Урок 35 · Напреднало · Версия: 2
  • Java · Урок 36 · Напреднало · Версия: 2
  • Java · Урок 37 · Напреднало · Версия: 2
  • Java · Урок 38 · Напреднало · Версия: 2

Източници