Werden Fehler, die in UncaughtExceptionHandler geworfen werden, verschluckt?

Question

Thread.UncaughtExceptionHandler besagt, dass, wenn die Methode, die nicht abgefangene Ausnahmen behandelt selbst eine Ausnahme auslöst, wird diese Ausnahme ignoriert:

void uncaughtException(Thread t, Throwable e):

Method invoked when the given thread terminates due to the given uncaught exception.

Any exception thrown by this method will be ignored by the Java Virtual Machine.

Jedoch, wenn ich es getestet habe die JVM die Ausnahmen nicht ignorieren die abgefangene Ausnahme handler` behandelt

public static void main(final String args[]) { 
    Thread.currentThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { 
     @Override 
     public void uncaughtException(Thread arg0, Throwable arg1) { 
      throw new java.lang.RuntimeException("e2"); 
     } 
    }); 
    throw new RuntimeException("e1"); 
} 

Eclipse-Console-Ausgang (JRE 1.7):

Exception: java.lang.RuntimeException thrown from the UncaughtExceptionHandler in thread "main"

Ein weiterer o ddity Ich fand heraus, dass die Ausgabe, die ich bekomme, nicht von System.err kommt. Es scheint von einem anderen Strom zusammen zu sein. Ich überprüfte dies durch System.err zu System.out Umleitung, aber ich bin immer noch „rot“ Ausgabe bekommen:

public static void main(final String[] args) { 
    System.setErr(System.out); 
    System.out.println(System.err == System.out); 
    System.err.println("this is black color"); 
    try { 
     throw new Error("test stacktrace color"); 
    } catch (Throwable e) { 
     e.printStackTrace(); 
    } 
    try { 
     Thread.sleep(2500); 
    } catch (InterruptedException e) { 
     e.printStackTrace(); 
    } 
    Thread.currentThread().setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { 
     @Override 
     public void uncaughtException(Thread t, Throwable e) { 
      throw new RuntimeException("from handler"); 
     } 
    }); 
    throw new RuntimeException("from main"); 
} 

Der Ausgang (bolded rot bedeutet Farbe):

true

this is black color

java.lang.Error: test stacktrace color at asf.df.main(df.java:13)

Exception: java.lang.RuntimeException thrown from the UncaughtExceptionHandler in thread "main"

Was ist die Erklärung für diese Phänomene?

Was passiert mit Fehlern, die in UncaughtExceptionHandler geworfen werden? Was ist das erwartete (dokumentierte oder garantierte) Verhalten?

Answer 1

HotSpot JVM gibt die Ausnahmen aus, die vom UncaughtExceptionHandler ausgelöst wurden. Siehe JavaThread::exit

if (HAS_PENDING_EXCEPTION) { 
     ResourceMark rm(this); 
     jio_fprintf(defaultStream::error_stream(), 
      "\nException: %s thrown from the UncaughtExceptionHandler" 
      " in thread \"%s\"\n", 
      pending_exception()->klass()->external_name(), 
      get_thread_name()); 
     CLEAR_PENDING_EXCEPTION; 
    } 

JVM druckt diese Ausnahme selbst direkt auf stderr unabhängig von dem System.err Zustand - ob umgeleitet wurde oder nicht.

Nun, diese Art der Warnung hat keinen Einfluss auf die Anwendung - in diesem Sinne wird die Ausnahme "ignoriert". Aber du hast Recht, dieses Verhalten ist nicht offensichtlich. Javadoc ist irreführend und sollte besser repariert werden.

Answer 2

Die Ausnahmen werden ignoriert und die Verarbeitung wird fortgesetzt, wenn sie von einem Nicht-Hauptthread ausgelöst wird.

Wenn es in main geworfen wird, ist der zurückgegebene Fehlercode ungleich Null.

Die nicht behandelten Ausnahmen werden über syserr protokolliert.

public static void main(final String[] args) { 

    final Thread myThread = new Thread(new Runnable() { 

     @Override 
     public void run() { 
      Thread.currentThread() 
       .setUncaughtExceptionHandler(new UncaughtExceptionHandler() { 

        @Override 
        public void uncaughtException(final Thread t, final Throwable e) { 

         System.out.println("In child UncaughtExceptionHandler at " + java.time.Instant.now()); 

         throw new RuntimeException("From child thread UncaughtExceptionHandler" 
           + java.time.Instant.now()); 

        } 
       }); 
      throw new RuntimeException("from runnable"); 
     } 
    }); 

    Thread.currentThread() 
    .setUncaughtExceptionHandler(new UncaughtExceptionHandler() { 

     @Override 
     public void uncaughtException(final Thread t, final Throwable e) { 

       System.out.println("In main UncaughtExceptionHandler " + java.time.Instant.now()); 

       throw new RuntimeException("From main thread UncaughtExceptionHandler" + java.time.Instant.now()); 

     } 
    }); 

    myThread.start(); 

    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(2)); 

    System.out.println("After child thread: " + java.time.Instant.now()); 

    //Will result in a non-zero return code 
    throw new RuntimeException("from main"); 
} 

Ausgang:

In Kind UncaughtExceptionHandler bei 2014-07-19T04: 10: 46.184Z

Ausnahme: java.lang.RuntimeException vom UncaughtExceptionHandler in thread „geworfen Faden 0 " Nach Kind thread: 2014-07-19T04: 10: 48.197Z Im Haupt UncaughtExceptionHandler 2014-07-19T04: 10: 48.197Z

Ausnahme: java.l ang.RuntimeException wird vom UncaughtExceptionHandler im Thread "main" ausgelöst