Thread.join(): примеры (JAVA)

Примеры использования Thread.join()

Пример 1: базовое использование join()

public class JoinExample {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            System.out.println("Поток начал работу");
            try { Thread.sleep(2000); } catch (InterruptedException e) {}
            System.out.println("Поток завершился");
        });
        worker.start();
        System.out.println("Главный поток ждёт завершения worker");
        worker.join();
        System.out.println("Главный поток продолжил работу");
    }
}

Главный поток ждёт завершения worker
Поток начал работу
Поток завершился
Главный поток продолжил работу

Пример 2: использование таймаута join(1000)

Thread worker = new Thread(() -> {
    try { Thread.sleep(3000); } catch (InterruptedException e) {}
});
worker.start();
worker.join(1000); // ждём не более 1 секунды
System.out.println("После join(1000) поток worker " + worker.isAlive() ? "ещё жив" : "завершён");

После join(1000) поток worker ещё жив

Пример 3: join(1000, 500000) – ожидание 1000 миллисекунд и 500 микросекунд (половина наносекунды). Поведение аналогично join(1000).

worker.join(1000, 500_000); // реально ждёт ~1000 мс
System.out.println("Ожидание завершено");

Альтернативы Thread.join() в Java

С развитием Java Concurrency API появились более гибкие механизмы:

• CountDownLatch

  – позволяет одному или нескольким потокам ожидать, пока не будет выполнено определённое количество операций. Подходит для случаев, когда нужно дождаться нескольких событий, а не просто одного завершённого потока.

• CyclicBarrier

  – синхронизация группы потоков в заданной точке. Все потоки ждут друг друга, после чего барьер сбрасывается. Полезен при параллельных вычислениях с этапами.

• Future.get()

  – блокирует вызывающий поток до получения результата от асинхронной задачи, отправленной в ExecutorService. Более высокоуровневый подход.

• CompletableFuture

  – позволяет комбинировать асинхронные операции, не блокируя поток явно. Методы join() и get() для ожидания результата.

• Phaser

  – повторяющийся барьер для динамического количества сторон.

Thread.join() остаётся простым и быстрым решением, когда требуется ожидание завершения одного конкретного потока. Для более сложной координации предпочтительны перечисленные выше классы из пакета java.util.concurrent.

Аналоги Thread.join() в других языках

Python (threading.Thread.join): синтаксически похож на Java, также требует обработки InterruptedException? В Python нет проверяемых исключений, но join() принимает таймаут. Пример:

import threading, time
def worker():
    time.sleep(2)
t = threading.Thread(target=worker)
t.start()
t.join(timeout=1)  # ждёт 1 секунду
print("Поток жив?", t.is_alive())

Поток жив? True

C# (System.Threading.Thread.Join): аналогично Java, перегрузки с миллисекундами и TimeSpan. Пример:

Thread t = new Thread(() => Thread.Sleep(2000));
t.Start();
t.Join(1000); // ждёт 1 сек
Console.WriteLine("Жив: " + t.IsAlive);

Жив: True

Go не имеет потоков в классическом смысле, но есть горутины. Для ожидания группы горутин используется sync.WaitGroup:

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    time.Sleep(2 * time.Second)
}()
wg.Wait() // ждёт завершения всех горутин

Kotlin при использовании Java-совместимого кода использует Thread.join(). Для корутин существует Job.join() (suspend-функция) в корутинах:

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        delay(2000)
    }
    job.join() // приостанавливает текущую корутину, не блокируя поток
}

PHP (pthreads): метод Thread::join() для ожидания завершения потока. Пример (требует расширение pthreads):

$thread = new class extends Thread {
    public function run() { sleep(2); }
};
$thread->start();
$thread->join(); // ждёт завершения

JavaScript (Web Workers) имеет worker.terminate() и postMessage, но нет прямого аналога блокирующего ожидания; используются колбэки и промисы.

Типичные ошибки при использовании Thread.join()

1. Необработанное InterruptedException
Метод объявляет проверяемое исключение, которое обязательно нужно обработать. Игнорирование приводит к ошибке компиляции.

Thread t = new Thread();
t.start();
t.join(); // ошибка компиляции: InterruptedException не обработан

2. Вызов join() на том же потоке
Поток не может ожидать сам себя, это приводит к deadlock.

Thread.currentThread().join(); // поток зависнет навсегда

Нет вывода, программа зависает.

3. Вызов join() до старта потока
Если вызвать join() до start(), то поток ещё не запущен. join() вернётся немедленно (так как поток не alive). Путаница может привести к логическим ошибкам.

Thread t = new Thread(() -> {
    System.out.println("Работа");
});
t.join(); // сразу возвращается, поток не запущен
t.start(); // поток стартует после ожидания

Нет вывода, или "Работа" может появиться после завершения main.

4. Забытый таймаут при опасности вечного ожидания
Если поток никогда не завершится (например, из-за бесконечного цикла), вызов join() без таймаута приведёт к зависанию вызывающего потока.

Thread t = new Thread(() -> { while(true); });
t.start();
t.join(); // бесконечное ожидание

Решение: использовать t.join(1000) с последующей проверкой t.isAlive().

Изменения метода Thread.join() в версиях Java

Метод Thread.join() существует с Java 1.0. Значительных изменений его сигнатуры или поведения в последующих версиях не было. В Java 5 был добавлен пакет java.util.concurrent с более мощными инструментами, но сам метод остался без изменений. В Java 8 и выше не вносились изменения, влияющие на его работу. Рекомендуется использовать новые API для сложных сценариев синхронизации, но join() остаётся востребованным для простых случаев.

Расширенные примеры использования Thread.join()

Пример 1: Ожидание нескольких потоков с таймаутом и проверкой состояния

public class JoinMultipleThreads {
    public static void main(String[] args) throws InterruptedException {
        Thread[] workers = new Thread[3];
        for (int i = 0; i < workers.length; i++) {
            int id = i;
            workers[i] = new Thread(() -> {
                try {
                    Thread.sleep((id + 1) * 1000); // 1,2,3 секунды
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Поток " + id + " завершён");
            });
            workers[i].start();
        }
        // Ждём каждый поток с таймаутом 2 секунды
        for (int i = 0; i < workers.length; i++) {
            workers[i].join(2000);
            System.out.println("Поток " + i + " жив после таймаута: " + workers[i].isAlive());
        }
        System.out.println("Готово");
    }
}

Поток 0 завершён
Поток 0 жив после таймаута: false
Поток 1 завершён
Поток 1 жив после таймаута: false
Поток 2 жив после таймаута: true
(примерно через 1 сек появляется "Поток 2 завершён", но main уже завершился)

Пример 2: Обработка InterruptedException в вызывающем потоке

Thread sleeper = new Thread(() -> {
    try { Thread.sleep(10000); } catch (InterruptedException e) {
        System.out.println("Sleeper прерван");
    }
});
sleeper.start();
Thread.currentThread().interrupt(); // прерываем main
try {
    sleeper.join(); // выкинет InterruptedException
} catch (InterruptedException e) {
    System.out.println("Main прерван во время join");
}
// Важно восстановить флаг прерывания:
Thread.currentThread().interrupt();

Main прерван во время join

Пример 3: Реализация простого барьера с помощью join()

Thread t1 = new Thread(() -> {
    System.out.println("t1: этап 1");
    // ...
});
Thread t2 = new Thread(() -> {
    System.out.println("t2: этап 1");
    // ...
});
t1.start();
t2.start();
t1.join();
t2.join();
// Теперь оба потока завершили этап 1, можно начинать этап 2
Thread t3 = new Thread(() -> System.out.println("t3: этап 2"));
t3.start();
t3.join();

Пример 4: Использование join() в ExecutorService (хотя обычно используют Future.get, но join также возможен):

ExecutorService executor = Executors.newSingleThreadExecutor();
Thread thread = new Thread(() -> {
    Future<?> future = executor.submit(() -> {
        try { Thread.sleep(1000); } catch (Exception e) {}
    });
    try { future.get(); } catch (Exception e) {}
});
thread.start();
thread.join(); // ждём завершения thread, который в свою очередь ждал future