Well, Once I got a scenario when someone asked me about
Runtime Exceptions. We know that Runtime
Exception should not be caught using catch block. Rather it is handled by JVM. So
JVM prints the stack trace and ends the program.
Is there any way to have little control on handling of these
uncaught exceptions?
As in the above diagram, we can see the hierarchy of
exceptions in Java. There could be 2 scenario when an exception could be
uncaught.
- Using Try – finally block without Catch : So here exception is not caught and it is automatically propagated to upper call hierarchy to handle it and finally reaches to JVM
- Occurrence of RunTime Exceptions which are directly handled by JVM.
In both the cases above JVM exception handler will take care
of this.
Java provides a beautiful API to have little control over Uncaught
Exception handling before JVM does it. This is Uncaught Exception Handler API of JVM.
Think of a scenario where you want an email or sms to be
sent to some concerned persons or any other application to be invoked, etc just when a uncaught exception or runtime
exception occurs and JVM terminates the program. At this point you would be
needing some hook point where you can process your customization and get
noticed. This can be provided by implementing Thread.UncaughtExceptionHandler.
So create a Class which would implement Thread.UncaughtExceptionHandler
and then use Thread.currentThread().setUncaughtExceptionHandler(new
MyUncaughtExceptionHandler());
Let’s understand this with an example.
public class
TestUncaughtException {
public static void main(String[] args)
{
Thread.currentThread().setUncaughtExceptionHandler(new
MyUncaughtExceptionHandler());
//try{
int i = 0;
System.out.println(50/i);
System.out.println("hello");
// }
/*catch(Exception
e){
System.out.println("in
catch");
}
finally{
System.out.println("divide
by zero");
}*/
}
}
class
MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler{
@Override
public void
uncaughtException(Thread t, Throwable e) {
System.out.println("in handler");
//System.out.println(e.getMessage());
//e.printStackTrace();
//
Custom code to do any extra processing
Thread.currentThread().getThreadGroup().uncaughtException(t,
e);
}
}
Code above seems to be self-explanatory . MyUncaughtExceptionHandler is my custom
hanlder which implements Thread.UncaughtExceptionHandler.
Write your customizations in uncaughtException(Thread t,
Throwable e) method.
Who is invoking this method. Yes, it is JVM. JVM calls
Thread.dispatchUncaughtException(Throwable e).
/**
* Dispatch an uncaught exception to the handler. This method is
* intended to be called only by the JVM.
*/
private void
dispatchUncaughtException(Throwable e) {
getUncaughtExceptionHandler().uncaughtException(this, e);
}
If this JVM does not finds any UncaughtExceptionHandler
set in specific thread then it calls ThreadGroup. uncaughtException(Thread
t, Throwable e).
Java Doc of this method says : Called by the Java Virtual Machine when a thread in this thread group
stops because of an uncaught exception, and the thread does not have a specific
Thread.UncaughtExceptionHandler installed.
And finally if this ThreadGroup is also not able to
handle this uncaught exception then it is handled by
defaultUncaughtExceptionHandler. Which is set by Thread. setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler
eh).
Java Doc for this says: Set the default handler invoked when a thread abruptly terminates due
to an uncaught exception, and no other handler has been defined for that
thread. Uncaught exception handling is controlled first by the thread, then by
the thread's ThreadGroup object and finally by the default uncaught exception
handler. If the thread does not have an explicit uncaught exception handler
set, and the thread's thread group (including parent thread groups) does not
specialize its uncaughtException method, then the default handler's
uncaughtException method will be invoked.
If you want to have more control on handling these
exceptions then you can try AOP which has got extra features to do it. But this
hook provided by JVM to have little control over it makes life easier enough.
Hope you like this article. Queries and suggestions are
most welcome.
CHEERS!!!
