Normally a Java thread (represented by any class that extends java.lang.Thread) stops when its run( ) method completes. In an abnormal case, such as when something goes wrong, the thread can terminate by throwing an exception. This exception trickles up the thread's ThreadGroup hierarchy, and if it gets to the root ThreadGroup, the default behavior is to print out the thread's name, exception name, exception message, and exception stack trace.
To get around this behavior (at least in Java 1.4 and earlier), you've got to insert your own code into the ThreadGroup hierarchy, handle the exception, and prevent delegation back to the root ThreadGroup. While this is certainly possible, you'll have to define your own subclass of ThreadGroup, make sure any Threads you create are assigned to that group, and generally do a lot of coding that has very little to do with the task at handactually handling the uncaught exception. Tiger simplifies all this dramatically, and lets you define uncaught exception handling on a per-Thread basis.
The java.lang.Thread class defines a nested interface in Tiger, called Thread.UncaughtExceptionHandler. You can create your own implementation of this interface and pass it to your target Thread's setUncaughtExceptionHandler( ) method (also new in Tiger). Example 10-1 is a simple Thread that does just this.
package com.oreilly.tiger.ch10;
public class BubbleSortThread extends Thread {
private int[] numbers;
public BubbleSortThread(int[] numbers) {
setName("Simple Thread");
setUncaughtExceptionHandler(
new SimpleThreadExceptionHandler( ));
this.numbers = numbers;
}
public void run( ) {
int index = numbers.length;
boolean finished = false;
while (!finished) {
index--;
finished = true;
for (int i=0; i<index; i++) {
// Create error condition
if (numbers[i+1] < 0) {
throw new IllegalArgumentException(
"Cannot pass negative numbers into this thread!");
}
if (numbers[i] > numbers[i+1]) {
// swap
int temp = numbers[i];
numbers[i] = numbers[i+1];
numbers[i+1] = temp;
finished = false;
}
}
}
}
}
class SimpleThreadExceptionHandler implements
Thread.UncaughtExceptionHandler {
public void uncaughtException(Thread t, Throwable e) {
System.err.printf("%s: %s at line %d of %s%n",
t.getName( ),
e.toString( ),
e.getStackTrace( )[0].getLineNumber( ),
e.getStackTrace( )[0].getFileName( ));
}
}
NOTE
I used a bubble sort for the example, but you should know that sorts like quicksort are much faster (and therefore much cooler).
This is a pretty normal Thread, with the exception of two items. First, there is a rather odd condition thrown into the sorting algorithm: if an int less than zero is in the supplied array, an IllegalArgumentException is tossed out. Second, to handle this (rather odd) case, an implementation of Thread.UncaughtExceptionHandler is defined, which prints out some additional information about the problem, including a line number and filename.
To see this in action, you can use Example 10-2, a simple test program.
package com.oreilly.tiger.ch10;
import java.io.IOException;
import java.io.PrintStream;
public class ThreadTester {
private int[] posArray = new int[] {1, 3, 6, 3, 4, 2, 5};
private int[] negArray = new int[] {-2, -8, -3, -9, -10};
public ThreadTester( ) {
}
public void testBubbleSort(PrintStream out) throws IOException {
Thread t1 = new BubbleSortThread(posArray);
t1.start( );
out.println("Testing with postive numbers...");
// Wait for the thread to complete
try {
t1.join( );
printArray(posArray, out);
} catch (InterruptedException ignored) { }
Thread t2 = new BubbleSortThread(negArray);
t2.start( );
out.println("Testing with negative numbers...");
try {
t2.join( );
printArray(negArray, out);
} catch (InterruptedException ignored) { }
}
private void printArray(int[] a, PrintStream out) throws IOException {
for (int n : a) {
out.println(n);
}
out.println( );
}
public static void main(String[] args) {
ThreadTester tester = new ThreadTester( );
try {
tester.testBubbleSort(System.out);
} catch (Exception e) {
e.printStackTrace( );
}
}
}
NOTE
Running "ant runch10" will automate this for you.
If you run this example, which generates an error when negative numbers are supplied in negArray, you'll see the SimpleExceptionHandler in action:
NOTE
While this is a fine example, it's still a bad idea to write to the console, or even System.err, unless you're sure where those errors are going, and that they will be seen by some set of human eyes. A better idea would be to log these errors somewhere useful.
[echo] Running ThreadTester... [java] Testing with postive numbers... [java] 1 [java] 2 [java] 3 [java] 3 [java] 4 [java] 5 [java] 6 [java] Testing with negative numbers... [java] Simple Thread: java.lang.IllegalArgumentException: Cannot pass negative numbers into this thread! at line 23 of BubbleSortThread.java [java] -2 [java] -8 [java] -3 [java] -9 [java] -10
Also, notice that the negative array (negArray) doesn't get sorted. That's because the thread threw an exception and never completed the sort.
...setting an UncaughtExceptionHandler for all threads? Install a default handler: pass an implementation of Thread.UncaughtExceptionHandler to the Thread.setDefaultUncaughtExceptionHandler( ), which is, of course, a static method:
Thread.setUncaughtExceptionHandler(new MyDefaultHandler( ));
If a Thread has its own handler, that of course overrides the default handler. In fact, here's the exact sequence of checks that the JVM goes through when determining how to handle an uncaught exception:
Check for a thread-specific handler to invoke, and if one exists, invoke it.
Invoke the handler of the containing ThreadGroup.
If the containing ThreadGroup (and its ancestors) have not overridden uncaughtException( ), pass the exception up the ThreadGroup hierarchy, until the root ThreadGroup is reached.
Invoke the default handler, obtained by calling Thread.getDefaultExceptionHandler( ).