Как можно прервать выполнение потока?

Прерывание потока в Java: методы и лучшие практики

Это фундаментальный вопрос, затрагивающий concurrency и контроль жизненного цикла потоков. Правильное прерывание критично для надёжного приложения.

Основной механизм: Interrupt Flag

Java предоставляет механизм прерывания через interrupt flag (флаг прерывания). Это не принудительное завершение потока, а мягкий сигнал:

Thread thread = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("Working...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // InterruptedException сбрасывает флаг!
            Thread.currentThread().interrupt();
            break;
        }
    }
    System.out.println("Thread finished");
});

thread.start();
Thread.sleep(3000);
thread.interrupt();  // Посылаем сигнал на прерывание

Ключевой момент: interrupt() устанавливает флаг, но не требует немедленное прерывание. Поток должен его проверять.

Методы прерывания

1. Использование InterruptedException

Некоторые методы Java выбрасывают InterruptedException, если поток был прерван:

• Thread.sleep()
• Object.wait()
• Thread.join()
• BlockingQueue.take(), put()

public void blockingOperation() throws InterruptedException {
    try {
        Thread.sleep(10000);
    } catch (InterruptedException e) {
        // Флаг был сброшен, восстанавливаем его
        Thread.currentThread().interrupt();
        throw new RuntimeException("Operation was interrupted", e);
    }
}

2. Проверка interrupt flag в цикле

Runnable task = () -> {
    while (!Thread.currentThread().isInterrupted()) {
        // Долгая работа
        doSomeWork();
    }
    System.out.println("Gracefully stopped");
};

Thread thread = new Thread(task);
thread.start();

// Где-то потом
thread.interrupt();
thread.join();  // Ждём, пока поток завершится

3. Future и ExecutorService

Для потоков из thread pool используй Future:

ExecutorService executor = Executors.newFixedThreadPool(2);

Future<?> future = executor.submit(() -> {
    try {
        while (!Thread.currentThread().isInterrupted()) {
            Thread.sleep(1000);
            System.out.println("Working");
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

// После 5 секунд
Thread.sleep(5000);
future.cancel(true);  // Пошлёт interrupt сигнал

executor.shutdown();
if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
    executor.shutdownNow();  // Force kill
}

Когда использовать cancel(true) vs cancel(false)

Future<?> future = executor.submit(longRunningTask);

// Вариант 1: Попытка мягкого завершения
future.cancel(true);  // Посылает interrupt сигнал

// Вариант 2: Только если задача ещё не началась
future.cancel(false);  // Не посылает interrupt, просто удаляет из очереди

Особенности работы с InterruptedException

Главное правило: Никогда не игнорируй InterruptedException!

// ❌ ПЛОХО — игнорируем прерывание
while (true) {
    try {
        blockingOperation();
    } catch (InterruptedException e) {
        System.out.println("Interrupted");
        // Флаг сброшен, цикл продолжится
    }
}

// ✅ ХОРОШО — пробрасываем или восстанавливаем флаг
public void work() throws InterruptedException {
    while (!Thread.currentThread().isInterrupted()) {
        try {
            blockingOperation();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            break;
        }
    }
}

Shutdown Hooks для graceful shutdown

Для приложения целиком используй shutdown hooks:

public class Application {
    private static ExecutorService executor = Executors.newFixedThreadPool(5);
    
    public static void main(String[] args) {
        // Регистрируем shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("Shutting down...");
            executor.shutdown();
            try {
                if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
                    List<Runnable> pending = executor.shutdownNow();
                    System.out.println("Force killed " + pending.size() + " tasks");
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }));
        
        // Основной код
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
    }
}

Примеры в реальных фреймворках

Spring Framework управляет потоками через стандартный механизм:

@Service
public class AsyncService {
    @Async
    public CompletableFuture<String> longRunningTask() throws InterruptedException {
        Thread.sleep(5000);
        return CompletableFuture.completedFuture("Done");
    }
}

// Использование
CompletableFuture<String> future = asyncService.longRunningTask();
future.get(2, TimeUnit.SECONDS);  // TimeoutException если затянется

Spring WebFlux использует Reactive подход для избежания блокирующих потоков:

@RestController
public class ReactiveController {
    @GetMapping("/slow")
    public Mono<String> slowOperation() {
        return Mono.fromCallable(() -> {
            Thread.sleep(5000);
            return "Done";
        })
        .timeout(Duration.ofSeconds(2))
        .onErrorMap(TimeoutException.class, 
            ex -> new ResponseStatusException(HttpStatus.REQUEST_TIMEOUT));
    }
}

Переходящие ошибки

Важно: Thread.stop() и Thread.suspend() устарели и опасны. Никогда их не используй!

// ❌ ЗАПРЕЩЕНО (deprecated и опасно)
thread.stop();
thread.suspend();
thread.resume();

// ✅ Правильный подход
thread.interrupt();

Тестирование прерывания

@Test
public void testThreadInterruption() throws InterruptedException {
    Thread thread = new Thread(() -> {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    });
    
    thread.start();
    Thread.sleep(50);
    thread.interrupt();
    thread.join(1000);
    
    assertFalse(thread.isAlive());
}

Итог

Прерывание потока в Java — это не насильственное завершение, а вежливый сигнал через interrupt flag. Правильный подход требует:

1. Проверки Thread.currentThread().isInterrupted()
2. Правильной обработки InterruptedException
3. Использования Future.cancel(true) для управления потоками
4. Shutdown hooks для graceful завершения приложения

Это обеспечивает надёжность и предотвращает утечки ресурсов.