How to properly stop the Thread in Java?

Fundamentals of Thread Termination

A sound understanding of ending the execution of a Java thread is essential to ensure resource cleanup and consistent state preservation. The volatile boolean flag technique is a powerhouse method, as it provides a clear stop sign to the thread to terminate at the earliest convenience — an almost artful stop.

Interrupts, the more edgy among siblings, allow threads to flee from blocked operations such as sleep() and wait(), making sure the, err..., "interruptions" are well-addressed.

Waking up from an I/O beauty sleep

When the thread is in the middle of I/O operations or comfy inside a sleep(), interrupt() acts like that annoying alarm and triggers an InterruptedException:

try {
    Thread.sleep(10000);
} catch (InterruptedException e) {
    // Yep, the sleep was rudely disturbed. Clean up & exit
}


Handling the Interrupt aftermath

Well, keeping cool after being rudely interrupted is tough, but threads in Java must abide by it. Hence, it's often best to keep the interrupt status flagged by calling Thread.currentThread().interrupt() when you catch this exception:

catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    // All hands on deck for cleanup
}


Spot-checks for Interruptions

Place checks for interruption status within your thread's run method to assure a well-timed stop:

while (!Thread.interrupted()) {
    // Keep marching, and look out for stop signals
}


Thread Collection, anyone?

An ExecutorService can steer the thread lifecycle through choppy waters with relative ease. A smooth, orderly shutdown of an executor service can ensure the thread completes its gift of gab:

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(new Task());

// Kicking-in an orderly shutdown, no more tasks accepted, lets finish the pending ones
executor.shutdown();
try {
    if(!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow(); // Throw in the towel on running tasks
    }
} catch (InterruptedException ex) {
    executor.shutdownNow(); // If this Thread got interrupted too, Re-cancel
    Thread.currentThread().interrupt(); // Let's not forget our status, shall we?
}


Advanced Shutdown Patterns

Other than your humble interrupt() and volatile flags, there are more nuanced shutdown patterns at your disposal.

Status Checks to Bring about Termination

Regular pit stops to review status can serve as effective preventive measures against missing a stop indicator or running into livelock situations or consuming more resources than essentially required.

Joining for a Co-ordinated Ballet

Much like a ballet performance, a timely join() can ensure the threads stay in sync and deliver a seamless termination performance:

Thread t = new Thread(new Task());
t.start();
// Other tasks at hand
t.join(); // Lets wait for little t to complete before moving on


The Art of Rising from Interruptions

An evolved system is adept at not only making threads fall in line promptly but also in dealing with the aftermath of interruptions with grace. A nimble recovery system decides whether to resume, exit, or log for posterity when an interruption strikes.

Those Stubborn Ones: Non-responsive Threads

For those bull-headed threads refusing to acknowledge interrupts due to an absence of interruptible operations, breaking your marathon operations or long sleeps into smaller, sprint-like cycles could do the trick:

while (!Thread.interrupted()) {
    // Get part of that task done
    // Time for a pit-stop, let's check for interruption too 
}


Cleanup and Resource Management

Threads often double up as resource managers and hence a mismanaged thread termination can lead to resource leaks:

try {
    // Resource Acquisition: the tug of war begins!
} finally {
    // Release resources: threads clean up after themselves
}


Keep a Close Eye with Monitoring and Debugging

For a smoother audit run, ensure logs are maintained for all operations and surprises in the form of interruptions on the thread:

catch (InterruptedException e) {
    // Time to spill some beans, log the interruption and thread status
}
finally {
    // The clean-up chronicles, logging the shutdown completion
}


To pick your rifle from the armory depends on the battleground. For instance, in a web application situation, managing the thread lifecycle with respect to the servlet's lifecycle can be effortlessly done using ServletContextListener.