Quand attraper java.lang.Error?

Dans quelles situations faut-il attraper java.lang.Errorune application?

En général, jamais.

Cependant, vous devez parfois détecter des erreurs spécifiques.

Si vous écrivez du code framework (chargement de classes tierces), il peut être judicieux d'attraper LinkageError (aucune définition de classe trouvée, lien insatisfait, changement de classe incompatible).

J'ai également vu du code tiers stupide lancer des sous-classes de Error, vous devrez donc les gérer également.

Au fait, je ne suis pas sûr qu'il ne soit pas possible de récupérer OutOfMemoryError.

Jamais. Vous ne pouvez jamais être sûr que l'application est capable d'exécuter la ligne de code suivante. Si vous obtenez un OutOfMemoryError, vous n'avez aucune garantie de pouvoir faire quoi que ce soit de manière fiable . Attrapez RuntimeException et vérifiez les exceptions, mais jamais les erreurs.

http://pmd.sourceforge.net/rules/strictexception.html

En général, vous devriez toujours attraper java.lang.Error et l'écrire dans un journal ou l'afficher à l'utilisateur. Je travaille en support et je constate quotidiennement que les programmeurs ne peuvent pas dire ce qui s'est passé dans un programme.

Si vous avez un thread démon, vous devez l'empêcher de se terminer. Dans d'autres cas, votre application fonctionnera correctement.

Vous ne devriez attraper java.lang.Errorqu'au plus haut niveau.

Si vous regardez la liste des erreurs, vous verrez que la plupart peuvent être traitées. Par exemple, a ZipErrorse produit lors de la lecture de fichiers zip corrompus.

Les erreurs les plus courantes sont OutOfMemoryErroret NoClassDefFoundError, qui sont les deux dans la plupart des cas des problèmes d'exécution.

Par exemple:

int length = Integer.parseInt(xyz);
byte[] buffer = new byte[length];

peut produire un OutOfMemoryErrormais c'est un problème d'exécution et aucune raison de terminer votre programme.

NoClassDefFoundErrorse produisent principalement si une bibliothèque n'est pas présente ou si vous travaillez avec une autre version de Java. S'il s'agit d'une partie facultative de votre programme, vous ne devez pas mettre fin à votre programme.

Je peux donner de nombreux autres exemples des raisons pour lesquelles il est judicieux de détecter Throwableau plus haut niveau et de produire un message d'erreur utile.

Dans un environnement multithread, vous voulez le plus souvent l'attraper! Lorsque vous l'attrapez, enregistrez-le et mettez fin à toute l'application! Si vous ne le faites pas, certains threads qui pourraient faire une partie cruciale seront morts et le reste de l'application pensera que tout est normal. En dehors de cela, de nombreuses situations indésirables peuvent survenir. Le plus petit problème est que vous ne pourrez pas trouver facilement la racine du problème si d'autres threads commencent à lancer des exceptions à cause d'un thread qui ne fonctionne pas.

Par exemple, la boucle doit généralement être:

try {
   while (shouldRun()) {
       doSomething();
   }
}
catch (Throwable t) {
   log(t);
   stop();
   System.exit(1);
}

Même dans certains cas, vous voudrez gérer différentes erreurs différemment, par exemple, sur OutOfMemoryError, vous pourrez fermer l'application régulièrement (même peut-être libérer de la mémoire et continuer), sur d'autres, vous ne pouvez pas faire grand chose.

Très rarement.

Je dirais seulement au niveau supérieur d'un fil afin d'essayer d'émettre un message avec la raison de la mort d'un fil.

Si vous êtes dans un cadre qui fait ce genre de chose pour vous, laissez-le au cadre.

Presque jamais. Les erreurs sont conçues pour être des problèmes auxquels les applications ne peuvent généralement rien faire. La seule exception peut être de gérer la présentation de l'erreur, mais même cela peut ne pas se dérouler comme prévu en fonction de l'erreur.

Un Errorne devrait généralement pas être attrapé , car cela indique une condition anormale qui ne devrait jamais se produire .

À partir de la spécification de l'API Java pour la Errorclasse:

An Errorest une sous-classe de Throwable qui indique des problèmes graves qu'une application raisonnable ne devrait pas essayer d'attraper. La plupart de ces erreurs sont des conditions anormales. [...]

Une méthode n'est pas obligée de déclarer dans sa clause throws des sous-classes d'erreur qui pourraient être levées pendant l'exécution de la méthode mais pas interceptées, car ces erreurs sont des conditions anormales qui ne devraient jamais se produire.

Comme l'indique la spécification, un Errorn'est lancé que dans des circonstances où il y a de fortes chances que, quand un Errorse produit, l'application ne puisse pas faire grand-chose, et dans certaines circonstances, la machine virtuelle Java elle-même peut être dans un état instable (tel que VirtualMachineError)

Bien que an Errorsoit une sous-classe de Throwablece qui signifie qu'elle peut être interceptée par une try-catchclause, mais ce n'est probablement pas vraiment nécessaire, car l'application sera dans un état anormal quand une Errorest lancée par la JVM.

Il y a aussi une courte section sur ce sujet dans la Section 11.5 La hiérarchie des exceptions de la spécification du langage Java, 2e édition .

Si vous êtes assez fou pour créer un nouveau framework de test unitaire, votre lanceur de test devra probablement attraper java.lang.AssertionError généré par tous les cas de test.

Sinon, voyez d'autres réponses.

Et il y a quelques autres cas où si vous détectez une erreur, vous devez la renvoyer . Par exemple, ThreadDeath ne devrait jamais être attrapé, cela peut causer un gros problème si vous l'attrapez dans un environnement confiné (par exemple, un serveur d'applications):

Une application ne doit intercepter les instances de cette classe que si elle doit nettoyer après avoir été arrêtée de manière asynchrone. Si ThreadDeath est intercepté par une méthode, il est important qu'il soit relancé afin que le thread meurt réellement.

Très, très rarement.

Je ne l'ai fait que pour un cas connu très très spécifique. Par exemple, java.lang.UnsatisfiedLinkError peut être renvoyé si deux ClassLoader d'indépendance chargent la même DLL. (Je suis d'accord que je devrais déplacer le JAR vers un chargeur de classe partagé)

Mais le cas le plus courant est que vous aviez besoin d'une journalisation afin de savoir ce qui s'est passé lorsque l'utilisateur vient se plaindre. Vous voulez un message ou une fenêtre contextuelle à l'utilisateur, plutôt que silencieusement mort.

Même programmeur en C / C ++, ils affichent une erreur et disent quelque chose que les gens ne comprennent pas avant de quitter (par exemple, une panne de mémoire).

Dans une application Android, j'attrape un java.lang.VerifyError . Une bibliothèque que j'utilise ne fonctionnera pas dans les appareils avec une ancienne version du système d'exploitation et le code de la bibliothèque générera une telle erreur. Je pourrais bien sûr éviter l'erreur en vérifiant la version du système d'exploitation au moment de l'exécution, mais:

• Le plus ancien SDK pris en charge peut changer à l'avenir pour la bibliothèque spécifique
• Le bloc d'erreur try-catch fait partie d'un mécanisme de repli plus important. Certains périphériques spécifiques, bien qu'ils soient censés prendre en charge la bibliothèque, lancent des exceptions. J'attrape VerifyError et toutes les exceptions pour utiliser une solution de secours.

c'est assez pratique d'attraper java.lang.AssertionError dans un environnement de test ...

Idéalement, nous ne devrions pas gérer / détecter les erreurs. Mais il peut y avoir des cas où nous devons le faire, en fonction des exigences du cadre ou de l'application. Disons que j'ai un démon XML Parser qui implémente l' analyseur DOM qui consomme plus de mémoire. S'il y a une exigence telle que le thread Parser ne doit pas être mort lorsqu'il obtient OutOfMemoryError , il doit à la place le gérer et envoyer un message / courrier à l'administrateur de l'application / du framework.

idéalement, nous ne devrions jamais détecter d'erreur dans notre application Java car il s'agit d'une condition anormale. L'application serait dans un état anormal et pourrait entraîner un basculement ou donner un résultat gravement faux.

Il peut être approprié de détecter une erreur dans les tests unitaires qui vérifient qu'une assertion est faite. Si quelqu'un désactive les assertions ou supprime d'une autre manière l'assertion que vous voudriez savoir

Une erreur se produit lorsque la JVM ne fonctionne plus comme prévu ou est sur le point de le faire. Si vous détectez une erreur, il n'y a aucune garantie que le bloc catch s'exécutera, et encore moins qu'il fonctionnera jusqu'à la fin.

Cela dépendra également de l'ordinateur en cours d'exécution, de l'état actuel de la mémoire, il n'y a donc aucun moyen de tester, d'essayer et de faire de votre mieux. Vous n'aurez qu'un résultat hasardeux.

Vous réduirez également la lisibilité de votre code.