JVM 如何处理未捕获异常

1
2
3
4
5
6
7

private static void testUncaughtException(String arg) {
try {
System.out.println(1 / arg.length());
} catch (ArithmeticException e) {
e.printStackTrace();
}
}

1
2
3
4
5
6
7

/**
* 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);
}

1
2
3
4
5
6
7
8
9
10
11
12
13

/**
* Returns the handler invoked when this thread abruptly terminates
* due to an uncaught exception. If this thread has not had an
* uncaught exception handler explicitly set then this thread’s
* ThreadGroup object is returned, unless this thread
* has terminated, in which case null is returned.
* @since 1.5
* @return the uncaught exception handler for this thread
*/
public UncaughtExceptionHandler getUncaughtExceptionHandler() {
return uncaughtExceptionHandler != null ?
uncaughtExceptionHandler : group;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

/**
* 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 {@link Thread.UncaughtExceptionHandler}
* installed.
*

* The uncaughtException method of
* ThreadGroup does the following:
*

*
• If this thread group has a parent thread group, the
  * uncaughtException method of that parent is called
  * with the same two arguments.
  *
• Otherwise, this method checks to see if there is a
  * {@linkplain Thread#getDefaultUncaughtExceptionHandler default
  * uncaught exception handler} installed, and if so, its
  * uncaughtException method is called with the same
  * two arguments.
  *
• Otherwise, this method determines if the Throwable
  * argument is an instance of {@link ThreadDeath}. If so, nothing
  * special is done. Otherwise, a message containing the
  * thread’s name, as returned from the thread’s {@link
  * Thread#getName getName} method, and a stack backtrace,
  * using the Throwable‘s {@link
  * Throwable#printStackTrace printStackTrace} method, is
  * printed to the {@linkplain System#err standard error stream}.
  *

*

* Applications can override this method in subclasses of
* ThreadGroup to provide alternative handling of
* uncaught exceptions.
*
* @param t the thread that is about to exit.
* @param e the uncaught exception.
* @since JDK1.0
*/
public void uncaughtException(Thread t, Throwable e) {
if (parent != null) {
parent.uncaughtException(t, e);
} else {
Thread.UncaughtExceptionHandler ueh =
Thread.getDefaultUncaughtExceptionHandler();
if (ueh != null) {
ueh.uncaughtException(t, e);
} else if (!(e instanceof ThreadDeath)) {
System.err.print(“Exception in thread “”
+ t.getName() + “” “);
e.printStackTrace(System.err);
}
}
}

1
2
3
4
5
6
7

private static void dumpThreadGroups() {
ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();
while(threadGroup != null) {
System.out.println(“dumpThreadGroups threadGroup=” + threadGroup.getName());
threadGroup = threadGroup.getParent();
}
}

1
2

dumpThreadGroups threadGroup=main
dumpThreadGroups threadGroup=system