A Java program with more than one execution thread only finishes when the execution of all of its threads end (more specifically, when all its non-daemon threads end their execution or when one of the threads uses the System.exit() method). Sometimes, you may need to finish a thread because you want to terminate a program or when a user of the program wants to cancel the tasks that a thread object is doing.

Java provides an interruption mechanism that indicates to a thread that you want to finish it. One peculiarity of this mechanism is that thread objects have to check whether they have been interrupted or not, and they can decide whether they respond to the finalization request or not. A thread object can ignore it and continue with its execution.

In this recipe, we will develop a program that creates a thread and forces its finalization after 5 seconds, using the interruption mechanism.

The example for this recipe has been implemented using the Eclipse IDE. If you use Eclipse or a different IDE, such as NetBeans, open it and create a new Java project.

Follow these steps to implement the example:

1. Create a class called PrimeGenerator that extends the Thread class:

        public class PrimeGenerator extends Thread{

2. Override the run() method including a loop that will run indefinitely. In this loop, process consecutive numbers beginning from one. For each number, calculate whether it's a prime number; if yes, as in this case, write it to the console:

        @Override 
        public void run() { 
          long number=1L; 
          while (true) { 
            if (isPrime(number)) { 
              System.out.printf("Number %d is Prime\n",number); 
            }

3. After processing a number, check whether the thread has been interrupted by calling the isInterrupted() method. If this method returns true, the thread has been interrupted. In this case, we write a message in the console and end the execution of the thread:

            if (isInterrupted()) { 
              System.out.printf("The Prime Generator has been
                                 Interrupted"); 
              return; 
            } 
            number++; 
          } 
        }

4. Implement the isPrime() method. You can get its code from the Creating, running, and setting information of a thread recipe of this chapter.
5. Now implement the main class of the example by implementing a class called Main and the main() method:

        public class Main { 
          public static void main(String[] args) {

6. Create and start an object of the PrimeGenerator class:

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

7. Wait for 5 seconds and interrupt the PrimeGenerator thread:

        try { 
          Thread.sleep(5000); 
        } catch (InterruptedException e) { 
          e.printStackTrace(); 
        } 
        task.interrupt();

8. Then, write information related to the status of the interrupted thread. The output of this piece of code will depend on whether the thread ends its execution before or after:

          System.out.printf("Main: Status of the Thread: %s\n",
                            task.getState()); 
          System.out.printf("Main: isInterrupted: %s\n",
                            task.isInterrupted()); 
          System.out.printf("Main: isAlive: %s\n", task.isAlive()); 
        }

9. Run the example and see the results.

The following screenshot shows the result of the execution of the previous example. We can see how the PrimeGenerator thread writes the message and ends its execution when it detects that it has been interrupted. Refer to the following screenshot:

The Thread class has an attribute that stores a boolean value indicating whether the thread has been interrupted or not. When you call the interrupt() method of a thread, you set that attribute to true. The isInterrupted() method only returns the value of that attribute.

The main() method writes information about the status of the interrupted thread. In this case, as this code is executed before the thread has finished its execution, the status is RUNNABLE, the return value of the isInterrupted() method is true, and the return value of the isAlive() method is true as well. If the interrupted Thread finishes its execution before the execution of this block of code (you can, for example, sleep the main thread for a second), the methods isInterrupted() and isAlive() will return a false value.

The Thread class has another method to check whether a thread has been interrupted or not. It's the static method, interrupted(), that checks whether the current thread has been interrupted or not.

As mentioned earlier, a thread object can ignore its interruption, but this is not the expected behavior.