Clause Fail Fast Finally en Java

Question

Existe-t-il un moyen de détecter, à partir de la clause finally, qu'une exception est en cours de lancement?

Voir l'exemple ci-dessous:

try {
    // code that may or may not throw an exception
} finally {
    SomeCleanupFunctionThatThrows();
    // if currently executing an exception, exit the program,
    // otherwise just let the exception thrown by the function
    // above propagate
}

ou si vous ignorez l'une des exceptions, vous ne pouvez rien faire?

En C ++, cela ne vous permet même pas d’ignorer l’une des exceptions et d’appeler simplement terminate (). La plupart des autres langues utilisent les mêmes règles que Java.

Answer 1

Définissez une variable d'indicateur, puis vérifiez-la dans la clause finally, comme suit:

boolean exceptionThrown = true;
try {
   mightThrowAnException();
   exceptionThrown = false;
} finally {
   if (exceptionThrown) {
      // Whatever you want to do
   }
}

Answer 2

Si vous vous trouvez dans cette situation, vous pourriez avoir un problème de conception. L'idée d'un "finalement" Le bloc est que vous voulez que quelque chose soit fait, quelle que soit la méthode utilisée. Il me semble que vous n’avez pas besoin d’un bloc final, mais que vous devriez simplement utiliser les blocs try-catch:

try {
   doSomethingDangerous(); // can throw exception
   onSuccess();
} catch (Exception ex) {
   onFailure();
}

Answer 3

Si une fonction lève et que vous voulez intercepter l'exception, vous devrez la placer dans un bloc try, c'est le moyen le plus sûr. Donc, dans votre exemple:

try {
    // ...
} finally {
    try {
        SomeCleanupFunctionThatThrows();
    } catch(Throwable t) { //or catch whatever you want here
        // exception handling code, or just ignore it
    }
}

Answer 4

Voulez-vous dire que vous souhaitez que le bloc finally agisse différemment selon que le bloc try a abouti?

Si oui, vous pouvez toujours faire quelque chose comme:

boolean exceptionThrown = false;
try {
    // ...
} catch(Throwable t) {
    exceptionThrown = true;
    // ...
} finally {
    try {
        SomeCleanupFunctionThatThrows();
    } catch(Throwable t) { 
        if(exceptionThrown) ...
    }
}

Cela devient de plus en plus compliqué, cependant ... vous voudrez peut-être penser à un moyen de restructurer votre code pour que cela soit inutile.

Answer 5

Non, je ne le crois pas. Le bloc catch fonctionnera jusqu'à la fin du bloc.

try {
    // code that may or may not throw an exception
} catch {
// catch block must exist.
finally {
    SomeCleanupFunctionThatThrows();
// this portion is ran after catch block finishes
}

Sinon, vous pouvez ajouter un objet synchronize () que le code d'exception utilisera, que vous pourrez archiver dans le bloc finally, ce qui vous aiderait à identifier si vous exécutez une exception dans un thread séparé.