What is cooperative interruption?

• interrupt() – sets the target thread's internal interrupt status flag to true; does not stop the thread.
• isInterrupted() – instance method that reads the flag without changing it; safe to poll in a loop.
• Thread.interrupted() – static method that reads the flag and clears it; use only when consuming the interruption.
• InterruptedException – thrown by blocking methods (sleep, wait, join, take) when the flag is set; clears the flag as part of throwing.
• Cooperative – the target thread decides when and how to respond, avoiding inconsistent state and held locks.

What does interrupt() do?

When the target is running normally, interrupt() sets the interrupt status flag to true. Nothing is forced; the worker keeps running until it checks the flag.

Thread worker = new Thread(() -> settleTradesLoop());
worker.start();
// Later, ask the worker to finish early:
worker.interrupt();  // sets the flag, does not stop the thread

What is the difference between isInterrupted() and interrupted()?

The instance method isInterrupted() returns the flag and leaves it unchanged. The static Thread.interrupted() returns the flag and clears it.

// Poll without clearing:
while (!Thread.currentThread().isInterrupted()) {
    processNextTrade();
}

// Consume and handle:
if (Thread.interrupted()) {
    cleanup();
    return;
}

A classic bug is calling the static interrupted() when you meant to only check, because it silently wipes the flag.

How do blocking methods respond to interruption?

If a thread is parked in sleep, wait, join, or BlockingQueue.take when interrupted, the method throws InterruptedException and clears the flag.

try {
    Thread.sleep(5000);
} catch (InterruptedException e) {
    // Flag was cleared by the throw
    Thread.currentThread().interrupt();  // restore the flag!
    return;
}

Swallowing InterruptedException without restoring the flag or stopping is one of the most common concurrency bugs.

What is the correct loop pattern?

package com.bank.worker;

import java.math.BigDecimal;
import java.util.concurrent.BlockingQueue;

public class SettlementWorker implements Runnable {

    private final BlockingQueue<Trade> queue;

    public SettlementWorker(BlockingQueue<Trade> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                Trade trade = queue.take();  // blocking call
                settle(trade);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();  // restore flag
                break;  // exit the loop cleanly
            }
        }
        System.out.println("Worker stopped cleanly.");
    }

    private void settle(Trade trade) {
        // settlement logic
    }
}

Why is interruption cooperative, not forced?

A thread may be holding locks, may be halfway through updating two accounts in a transfer, or may own an open file. If the JVM forcibly killed it at an arbitrary instruction, it could leave shared state inconsistent. By making the thread choose a safe point, Java guarantees cancellation happens only where the code is in a consistent state.

What are common mistakes?

// WRONG: swallows the interruption signal
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // does nothing: cancellation signal is lost!
}

// CORRECT: restore the flag or stop
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();  // preserve the signal
}

How do Future.cancel and shutdownNow use interrupt?

Future.cancel(true) interrupts the running task's thread. ExecutorService.shutdownNow() interrupts the pool's worker threads. Your tasks must be interruption-aware for a clean shutdown.

What are common interview follow-up questions?

• How does ClosedByInterruptException work for NIO channels?
• What happens if you interrupt a thread that is not blocking?
• How do virtual threads handle interruption?