Falhar rápido finalmente cláusula em Java

Question

Existe uma maneira de detectar, a partir de dentro cláusula finalmente, que uma exceção é o processo de ser jogado?

Veja o exemplo abaixo:

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 está ignorando uma das exceções a única coisa que você pode fazer?

Em C++ não mesmo que você ignorar uma das exceções e apenas chamadas de terminate().A maioria das outras línguas usam as mesmas regras como java.

Answer 1

Definir uma variável de sinalizador e, em seguida, verifique para ele na cláusula finalmente, como:

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

Answer 2

Se você encontrar-se fazendo isso, então você pode ter um problema com o seu design.A ideia de um bloco "finally" é que você quer que algo seja feito, independentemente de como o método sai.Parece-me que você não precisa de um bloco finally, e deve apenas utilizar os blocos try-catch:

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

Answer 3

Se uma função lança e você deseja capturar a exceção, você vai ter que moldar a função de um bloco try, é a maneira mais segura.Assim, em seu exemplo:

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

Answer 4

Você quer dizer que quer o bloco finally para agir de forma diferente, dependendo se o bloco try concluída com êxito?

Se assim for, você sempre pode fazer algo como:

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

Que está ficando muito complicado, embora...você pode querer pensar em uma maneira de reestruturar o código para fazer isso desnecessário.

Answer 5

Não, eu não acredito que sim.O bloco catch será executado para conclusão antes de o bloco finally.

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
}

Caso contrário, você pode adicionar um sincronizar() do objeto que o código de exceção vai usar, que você pode verificar no bloco finally, que iria ajudá-lo a identificar se em um thread separado você estiver executando uma exceção.