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:

        public class ExceptionHandler implements UncaughtExceptionHandler { 
          @Override 
          public void uncaughtException(Thread t, Throwable e) { 
            System.out.printf("An exception has been captured\n"); 
            System.out.printf("Thread: %s\n",t.getId()); 
            System.out.printf("Exception: %s: %s\n",
                              e.getClass().getName(),e.getMessage()); 
            System.out.printf("Stack Trace: \n"); 
            e.printStackTrace(System.out); 
            System.out.printf("Thread status: %s\n",t.getState()); 
          } 
        }

        public class Task implements Runnable { 
          @Override 
          public void run() { 
            int numero=Integer.parseInt("TTT"); 
          } 
        }

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

            Task task=new Task(); 
            Thread thread=new Thread(task); 
            thread.setUncaughtExceptionHandler(new ExceptionHandler()); 
            thread.start(); 
          } 
        }

In the following screenshot, you can see the results of the execution of the example. The exception is thrown and captured by the handler that writes the information about Exception and Thread that threw it. This information is presented in the console:

When an exception is thrown in a thread and remains uncaught (it has to be an unchecked exception), the JVM checks whether the thread has an uncaught exception handler set by the corresponding method. If it does, the JVM invokes this method with the Thread object and Exception as arguments.

If the thread doesn't have an uncaught exception handler, the JVM prints the stack trace in the console and ends the execution of the thread that had thrown the exception.

The Thread class has another method related to the process of uncaught exceptions. It's the static method setDefaultUncaughtExceptionHandler() that establishes an exception handler for all the thread objects in the application.

When an uncaught exception is thrown in the thread, the JVM looks for three possible handlers for this exception.

First it looks for the uncaught exception handler of the thread objects, as we learned in this recipe. If this handler doesn't exist, the JVM looks for the uncaught exception handler of ThreadGroup as explained in the Grouping threads and processing uncontrolled exceptions in a group of threads recipe. If this method doesn't exist, the JVM looks for the default uncaught exception handler, as we learned in this recipe.

If none of the handlers exits, the JVM writes the stack trace of the exception in the console and ends the execution of the Thread that had thrown the exception.