Uncaught exceptions thrown in overridden ThreadGroup.uncaughtException

Question

Hi,
To process uncaught exceptions in threads I spawn, I have created a ThreadGroup and overridden the uncaughtException method. This works flawlessly, but it brought up the following question:
What happens to an exception that is thrown in an overridden uncaughtException method that is not caught?
I assumed that an uncaught exception in an uncaughtException method would call the uncaughtException method in the parent thread group, but this does not seem to be the case. The uncaught exception just seems to disappear.
Can somebody please confirm my finding that an uncaught exception thrown there just disappears and does not get handled anywhere else? Can somebody point me to the right sections of the Java Language Specs or the JVM Specs that deal with this issue?
Below is a test program that I wrote to investigate. It throws an exception in an "outer thread", part of an "outer group" thread group; an exception in an "inner thread", part of an "inner group" thread group; and an exception in the uncaughtException method of the "inner group" thread group. I expected that the first two invoke the uncaughtException of the "outer group", while the last one invokes the method of the "inner group". Contrary to my expectations, the exception thrown in the uncaughtException method of the "inner group" does not seem to invoke anything.
Thanks in advance.
Yours,
--Mathias
public class ThrowInUncaughtExceptionHandler {
public static void main(String[] args) {
(new ThrowInUncaughtExceptionHandler()).run();
public void run() {
ThreadGroup outerGroup = new ThreadGroup("outer") {
public void uncaughtException(Thread t, Throwable e) {
System.out.println("in outerGroup.uncaughtException: "+e);
final Thread outerThread = new Thread(outerGroup, new Runnable() {
public void run() {
System.out.println("in outerThread.run");
System.out.println("\tthread group: "+Thread.currentThread().getThreadGroup());
System.out.flush();
ThreadGroup innerGroup = new ThreadGroup("inner") {
public void uncaughtException(Thread t, Throwable e) {
System.out.println("in innerGroup.uncaughtException: "+e);
System.out.println("\tthrowing another exception...");
throw new RuntimeException("thrown in innerGroup.uncaughtException");
final Thread innerThread = new Thread(innerGroup, new Runnable() {
public void run() {
System.out.println("in innerThread.run");
System.out.println("\tthread group: "+Thread.currentThread().getThreadGroup());
System.out.flush();
throw new RuntimeException("thrown in innerThread");
innerThread.start();
try { innerThread.join(); }
catch(InterruptedException ioe) { /* ignore */ }
throw new RuntimeException("thrown in outerThread");
outerThread.start();
}

Answer 1

Hi tigerxx:
Thank you for your reply. Unfortunately, your suggestion does not help. I had tried it already, even though according to the Java API Javadocs, this is not necessary anyway: If no thread group is specified as parent of a thread group, then the current thread's thread group is used. Since innerGroup is created by a thread in outerGroup, innerGroup's parent is outerGroup.
Thanks again, though, for taking the time to read and reply.
--Mathias