Ce qui est plus rapide, essayez de l'attraper ou si-sinon en java (WRT performance)

Lequel est le plus rapide:

Soit ce 

try {
  n.foo();
} 
catch(NullPointerException ex) {
}

ou

if (n != null) n.foo();
  • Comment à propos de "Qui est plus lisible?" La Performance est votre dernière préoccupation.
  • Utilisation de try-catch clause de cette façon est certainement une mauvaise idée. Aussi try-catch résultats dans instantinating de new object (l'exception). Donc je dirais que (n!=null) est plus rapide dans le cas où vous avez un grand nombre de cas où n == null. Aussi n!=la valeur null est ultra-rapide à construire.
  • La Performance est très différente selon que n est nul ou pas.
  • "Aussi try-catch résultats dans instantinating de new object (l'exception)". Non, il n'est pas. Lancer une exception ne.
  • Hmm, bizarre que c'est le sujet du dernier Javaspecialists bulletin de quiz. Heinz M. Kabutz ne soutiennent que la première forme est en effet très mauvais pour la performance. Il n'est cependant fournir une information supplémentaire: n est nulle de 10% du temps.
  • Ils sont différents... la première forme sera aussi attraper les Npe générée à partir de foo()
  • il ne le fait pas. Lancer une exception ne." Non, il n'est pas. 😉 La construction de la levée d'une exception n'. Du code peut choisir volontairement lever de nouveau la même exception, encore et encore (aussi fou que ça puisse être). Désolé, j'ai juste eu à rajouter. 🙂
  • Dans le très ancien des jours exceptions ont été lents (car ils ont capturé la trace de la pile lors de la génération). Aujourd'hui, ils sont plus rapides, mais il reste encore beaucoup de travail qui est inutile dans ce cas.
  • Je suis venu ici demandais la même chose. Ce sujet le cas où vous êtes à la recherche pour une condition qui se produit une fois, et une seule fois (parce que vos prises block fait une initialisation de la base de l'information dans un argument), sur un programme qui pourrait fonctionner pendant des heures? En gros, est-ce plus rapide de passer par un essai qui réussit toujours que SI c'est toujours vrai? Est-il un coût à long terme à un essai qui réussit toujours? En Python, ils encouragent ce genre de chose - pourquoi le cours de l'histoire en Java?

InformationsquelleAutor Rakesh | 2010-08-16
  1. 52

    Ce n'est pas une question de qui est plus rapide, mais plutôt de justesse.

    Une exception est pour les circonstances qui sont exactement ce que, exceptionnelle.

    Si c'est possible pour n être null dans le cadre normal des affaires, de la logique, puis utiliser une if..else, d'autre throw une exception.

    • Comme d'habitude, la première affiche qui dit "ne pas faire de l'optimisation prématurée" obtient le plus upvotes. Cette question n'est pas à propos de ce qui est correct, le meilleur, ou le plus lisible, mais ce qui est plus rapide. L'OP la plus probable à cette question dans le dernier numéro de la Java Spécialiste de la Newsletter, ce qui signifie qu'ils sont sans doute intéressés à en apprendre la raison pourquoi la version la plus rapide est plus rapide (et ainsi d'approfondir leur compréhension de la VM internes), plutôt que de penser la mise en œuvre de cette dans le code de production.
    • Tout en étant d'abord fait parfois le plus upvotes, ma limite journalière a été atteint il y a quelques temps. Je maintiens ma réponse. Je suis sûr que vous êtes conscient que la question posée n'est pas toujours la vraie question. Il n'y a aucune mention de VM internes. S'il y avait eu je pourrais avoir formulé ma réponse différemment.
    • Oui, c'était une question qui est plus rapide -- regardez l'original OP question. Il peut ne pas être les "meilleures pratiques" prématurément optimiser la solution, mais peut-être que l'OP a été intéressés à en apprendre quelque chose sur la façon dont ces choses sont mises en œuvre.
    • parfois, vous vous déplacez au-delà de ce qui est demandé, et de répondre à la vraie question.
    InformationsquelleAutor Mitch Wheat
  2. 53
    if (n != null) n.foo();

    est plus rapide.

    • +1 pour répondre à ce qui est remis en cause, et non pas ce qui est correct.
    • L'exactitude est toujours plus importante que la vitesse. Un programme qui s'exécute rapidement, mais inexacte, est inutile.
    • Vous pouvez toujours obtenir un NPE si quelque chose dans foo() se jette sur elle. Depuis je ne sais pas ce qui est à l'intérieur de foo() affirmant ceci est incorrect. Donc, si à l'intérieur de foo() que vous avez à faire beaucoup de "if( x != null)", puis la capture de l'exception ici est plus rapide.
    • l'exactitude seul ne permet pas de répondre à la question. Il est sans importance si il est prématuré d'optimisation ou pas. Répondez à la question et ajouter un avertissement pour votre réponse, au lieu de simplement répéter les "prématuré" optimisation de l'évangile pour obtenir upvoted
    • Il y a une bonne raison de "l'optimisation" est l'évangile...
    • Blé oui, car il est le peuple qui fait de copier coller qu'il convient de voter pour quelque chose qui n'a pas été posée. Il n'y a aucune raison de répondre à la question et de donner un bon conseil serait mutuellement exclusifs. Pour ne pas dire que l'optimisation n'est pas mal, mais autonome, ce n'est pas une réponse valable pour toute question à propos de la performance.
    • vous êtes loin de la marque. Depuis plus de 25 ans d'expérience de la programmation, je peux personnellement vous assurer que Knuth conseils sur l'optimisation prématurée est tout aussi pertinente que quand il fait+ de 20 ans.
    • Le blé je n'ai jamais dit que ce n'était pas valide ou de bons conseils, ce que je voulais souligner, c'est qu'il ne répond pas à la question posée - il n'est qu'une partie de la réponse.
    • Juyal: Bon commentaire! J'ai vraiment me dérange quand quelqu'un pose une question et les réponses toutes comprennent "qu'est-Ce que le cas d'utilisation?", même lorsque la question est claire. N'est-il pas suffisant de vouloir connaître la réponse, sans avoir à justifier de la question?
    • -1 parce que vous n'avez pas expliquer pourquoi c'est plus rapide.
    • Où sont vos preuves?
    • La question était de Qui est le plus rapide? pas Pourquoi il est le plus rapide?. Vous ne devriez pas lui donner -1 parce que vous êtes dans la mauvaise question
    • Et si vous faites le test de dix milliards de fois et que vous venez de s'attendre à une valeur nulle à une couple de fois? Faut-il encore prendre du temps rien que pour entrer et sortir du for déclaration ou serait-ce la méthode la plus rapide dans ce cas?

    InformationsquelleAutor Boris Pavlović
  3. 33

    Explicitement de test pour un pointeur null est beaucoup plus rapide que la gestion des exceptions.

    Pour l'enregistrement, plus de la oherheads en utilisant les exceptions sont engagés dans la instanciation de l'objet de l'exception. En particulier dans l'appel à fillInStackTrace() qui a pour:

    • examiner chaque frame de pile pour la pile du thread actuel, et
    • créer une structure de données pour capturer le cadre de la pile de détails.

    Dans certains cas, vous pouvez réduire ce en réutilisant l'objet de l'exception, ou par substitution d'une application spécifique exception du fillInStackTrace() méthode pour en faire un no-op. La baisse dans les deux cas, c'est que bon stacktraces ne seront plus disponibles pour vous aider à déboguer des exceptions inattendues. (Et aucune de ces sont applicables à l'OP de l'exemple.)

    Alors que l'exception de l'instanciation est cher, à l'exception de lancer, de propagation et de rattrapage ne sont pas exactement bon marché non plus.

    Il y a une deuxième raison pour laquelle explicite null test est une meilleure idée. Considérez ceci:

    try {
    doSomething(a.field);
} catch (NullPointerException ex) {
    System.err.println("a.field is null");
}

    Ce qui se passe si une NPE se passe au sein de l'appel à doSomething(...) au lieu de cours de l'évaluation de la a.field expression? Bien sûr, nous allons attraper un NPE, mais nous allons faire une erreur de diagnostic, et ensuite essayer de continuer ... supposant à tort que a.field n'est pas défini ou quelque chose.

    À distinguer un "attendu" NPE à partir d'un "imprévu" NPE est possible en théorie, mais en pratique très difficile. Beaucoup plus simple et plus robuste approche est explicitement test pour la null valeurs que vous attendez (par exemple avec un if déclaration), et de traiter toutes les Npe comme des bugs.

    (Je suis sûr que c'est ce @Mitch entend par "traitement des exceptions exceptionnelles", mais je pense qu'il est utile de préciser les choses avec un exemple ...)

    • Hehe, bien sûr, quelqu'un DOIT de proposer de jeter un oeil dans la trace de la pile pour voir si vous êtes à l'intérieur ou à l'extérieur de la doSomething() 🙂
    • Vrai. C'est pourquoi j'ai dit "théoriquement possible, mais en pratique très difficile". La partie difficile est de distinguer les attendus et inattendus des cas, de façon à ne pas donner de faux négatifs ou de faux positifs si quelqu'un fait un changement qui modifie les numéros de ligne, etc.
    • C: il est exact que les testant la valeur null est plus rapide, mais comme Martin Odersky a souligné dans un de ses discours sur la Scala, la création d'un statique Exception objet, puis de le jeter à plusieurs reprises (pour simuler une break déclaration de l'intérieur d'une fermeture), est très rapide.
    • cela ne s'applique pas dans le cas des OP exemple. Et de toute façon, le coût de juste lancer et attraper une statique à l'exception de l'instance va être plus une instruction if. (Et ne vous attendez pas le compilateur JIT gens à aller très loin pour optimiser l'exception de l'abus.)
    • C: je n'étais pas ce qui suggère que de jeter une Exception, c'est mieux. Le commentaire à propos de Martin Odersky parler était plus intéressant de côté.
    • Je ne veux pas que les gens l'idée erronée; c'est à dire que "très rapide " est plus rapide qu'une simple instruction if.

    InformationsquelleAutor Stephen C
  4. 24

    La réponse n'est pas aussi simple qu'il y paraît, car cela dépendra du pourcentage de fois que l'objet est vraiment nul. Lorsque cela est très rare (disons de 0,1% du temps), il pourrait même être plus rapide. Pour tester ce que j'ai fait quelques comparaisons avec les résultats suivants (avec la version 1.6 de Java client):

    Benchmaring with factor 1.0E-4
Average time of NullIfTest: 0.44 seconds
Average time of NullExceptionTest: 0.45 seconds
Benchmaring with factor 0.0010
Average time of NullIfTest: 0.44 seconds
Average time of NullExceptionTest: 0.46 seconds
Benchmaring with factor 0.01
Average time of NullIfTest: 0.42 seconds
Average time of NullExceptionTest: 0.52 seconds
Benchmaring with factor 0.1
Average time of NullIfTest: 0.41 seconds
Average time of NullExceptionTest: 1.30 seconds
Benchmaring with factor 0.9
Average time of NullIfTest: 0.07 seconds
Average time of NullExceptionTest: 7.48 seconds

    Cela semble assez concluante pour moi. NPE sont juste très lent. (Je peux poster le benchmarking code si vous le souhaitez)

    edit:
    Je viens de faire une découverte intéressante: lorsque l'analyse comparative à l'aide de la JVM de serveur, les résultats changent radicalement:

    Benchmaring with factor 1.0E-4
Average time of NullIfTest: 0.33 seconds
Average time of NullExceptionTest: 0.33 seconds
Benchmaring with factor 0.0010
Average time of NullIfTest: 0.32 seconds
Average time of NullExceptionTest: 0.33 seconds
Benchmaring with factor 0.01
Average time of NullIfTest: 0.31 seconds
Average time of NullExceptionTest: 0.32 seconds
Benchmaring with factor 0.1
Average time of NullIfTest: 0.28 seconds
Average time of NullExceptionTest: 0.30 seconds
Benchmaring with factor 0.9
Average time of NullIfTest: 0.05 seconds
Average time of NullExceptionTest: 0.04 seconds

    À l'aide du serveur de VM, la différence est à peine visible. Encore: je préfère ne pas utiliser la capture de NullPointerException moins que c'est vraiment une exception.

    • Méfiez - vous- Java micro-benchmarks sont très difficiles à obtenir le droit. Sans voir ton code, il est impossible de dire si vos résultats sont significatifs.
    • C - j'ai posté le code sur github - github.com/marcdejonge/javabenchmarking . On peut peut-être ajouter plus de ces points de référence dans l'avenir et de construire un cadre complet pour la microbenchmarks.
    • J'ai regardé ces repères, et ils sont un peu louches, de l'OMI. Le compilateur JIT peut avoir compris que les deux execute méthodes ont été efficacement no-ops et optimisé loin. Aussi. vous ne faites rien pour s'assurer que les méthodes sont JIT compilé, ou pour permettre la surcharge du PROCESSEUR de compilation JIT.
    • C - Le compilateur JIT ne peut pas optimiser la fonction de loin, parce qu'il ne sait pas de quel côté effets que la fonction a l'. En outre, le test est exécuté 10 fois pour permettre à la première (et peut-être le second) pour être ignoré. Lors du calcul de la moyenne des temps, la manière la plus rapide et la plus lente, les temps sont ignorés.
    • BTW, j'ai trouvé pourquoi la version du serveur est beaucoup plus rapide: il ne crée pas une stacktrace. Apparemment, le compilateur JIT sait que la stacktrace n'est pas utilisé et il retourne une chaîne vide (singleton) de l'instance de l'exception NullPointerException.
    • Qu'est ce que le client de la version de Java et donc il est beaucoup plus lent. Mais le point est que les deux morceaux de code à accomplir presque la même chose lorsque vous tout simplement ignorer l'exception. C'est en faisant usage de la smart compilateur JIT, bien qu'il n'est pas une méthode recommandée pour la programmation.
    • Là vous allez. Le compilateur JIT a apparemment optimisé la plupart des choses que vous étiez en train de mesurer. Je pense aussi qu'un assez intelligent compilateur JIT pourrait comprendre que tous les objets sont java.lang.Object instances et que la toString() ainsi, les appels sont sans effets secondaires. Vous avez vraiment besoin de changer les critères de référence de sorte que les valeurs des expressions sont utilisées. Par exemple, faire de les objets Integer instances et la somme de leurs intValue() valeurs.
    • En outre, sans regarder le code natif, il n'est pas possible d'être sûr de ce qui se passe vraiment ici. Nous ne savons même pas sûr que le compilateur JIT est utilisé.
    • J'ai essayé la suggestion que vous avez fait, par le remplacement de l'Objet.toString() avec Entier.intValue() (et en additionnant les valeurs). Cela ne fait aucune différence dans les conclusions, mais le intValue est beaucoup plus rapide.

    InformationsquelleAutor Marc
  5. 8

    Si n.foo() arrive à lancer en interne un NPE, vous partez pour une longue session de débogage (ou pire encore, votre application échoue dans la production..). Il suffit de ne pas le faire.

    Combien de nano-secondes envisagez-vous d'enregistrer, de toute façon?

    • +1 pour mettre les économies possibles en perspective.
    InformationsquelleAutor Enno Shioji
  6. 7

    Je remarque que je ne suis pas le seul à lire le Java du Spécialiste de la Newsletter 🙂

    Outre le fait qu'il y a un différence sémantique (les entrées en phase nationale n'est pas nécessairement causée par référence à n, il pourrait avoir été jeté par une erreur dans foo()), et un lisibilité question (le try/catch est plus déroutant pour un lecteur que l' if), ils devraient être tout aussi rapide dans le cas où n != null (avec le si/d'autre version ayant un léger avantage), mais quand n == null si/d'autre est beaucoup plus rapide. Pourquoi?

    1. Quand n == null, la machine virtuelle doit créer une nouvelle exception à l'objet et de remplir ses trace de la pile. La trace de la pile de l'info, c'est vraiment cher à acquérir, voici donc le try/catch version est beaucoup plus cher.
    2. Certains croient que les instructions conditionnelles sont plus lents car ils empêchent les instruction de traitement en pipeline, et en évitant l'explicite if ils pensent qu'ils s'en aille pas cher quand n != null. La chose est, cependant, que la VM va faire un implicite null vérifier quand déréférencement... qui est, à moins que l'équipe peut déterminer que n doit être non null, qu'il peut dans le si/d'autre version. Cela signifie que le if/else et try/catch versions devraient être effectuer environ le même. Mais...
    3. ... try/catch clauses peuvent interférer avec la façon dont l'équipe peut inline les appels de méthode, ce qui signifie qu'il pourrait ne pas être en mesure d'optimiser le try/catch version ainsi que le if/else.
    • +1 pour n évangile + conseils + répondre à la vraie question
    InformationsquelleAutor gustafc
  7. 3

    À côté de la bonne réponse (utilisation des exceptions pour des cas exceptionnels), je vois que vous êtes essentiellement en essayant d'éviter les nuls vérifie partout. Java 7 aura un "null sécuritaire" de l'opérateur qui va retourner la valeur null lorsque n?.foo() est appelé au lieu de lancer des NPE. C'est empruntée au langage Groovy. Il y a aussi une tendance à éviter d'utiliser la valeur null tout à fait dans son code, sauf lorsque c'est vraiment nécessaire (c'est à dire: le contact avec les bibliothèques). Voir cette autre réponse, pour plus de discussion sur ce point.
    Éviter != null états

    • Je pense que le elvis opérateur b?.foo() ) n'a en fait été exclus de JDK 7, et il n'y a pas de plans pour l'inclure.
    • "Il y a aussi une tendance à éviter d'utiliser la valeur null tout à fait" je ne pense pas que ce soit une tendance. Retour de/à l'aide de null a été une mauvaise pratique pour toujours. Je n'ai pas trouver encore d'une situation en vertu de laquelle une méthode doit retourner la valeur null au lieu de lancer une exception.
    • Comment sur la spécification d'une valeur quelconque? Avez-vous lancer une exception si l'application ne permet pas de disposer de certaines données à remplir (encore)?
    • eh bien, je pense que c'est un état exceptionnel, pour lequel le processus de donnée n'est pas prête à gérer, car il ne devrait pas être appelée que si les données ne sont pas là pour lui à gérer.
    • Êtes-vous vraiment lancer une exception au lieu de retourner la valeur null signifie par exemple "date de livraison n'est pas encore connu"?
    • Voir ce blog intéressant sur la mise en œuvre de la Elvis opérateur en Scala: codecommit.com/blog/scala/...

    InformationsquelleAutor Bernard
  8. 2

    Il est généralement coûteux à gérer les exceptions. Le VM Spec peut vous donner un aperçu de la façon dont beaucoup, mais dans le cas ci-dessus if (n != null) n.foo(); est plus rapide.

    Bien que je suis d'accord avec Mitch Blé concernant la vraie question est la décision correcte.

    @Mitch Blé Dans sa défense, c'est un joli exemple artificiel. 🙂

    • Des Exceptions ne sont chères si elles se produisent (et je pense que le coût est plus sur le lancer que sur la capture). Si l'exception (presque) n'arrive jamais, ne vérifiant pas la valeur null peut être plus rapide. Pour défendre l'OP, en Python, il est recommandé de laisser l'exception arriver.
    InformationsquelleAutor linuxuser27
  9. 1

    La si construction est plus rapide. La condition peut être facilement traduit en code machine (processeur des instructions).

    L'alternative (try-catch) nécessite la création d'une NullPointerException objet.

    InformationsquelleAutor Andreas_D
  10. 0

    Certainement la deuxième forme est beaucoup plus rapide. Dans le try-catch scénario, il jette un exception qui ne un new Exception() de certaine forme. Puis le catch bloc est appelé qui est un appel de méthode et doit exécuter n'importe quel code est en elle. Vous obtenez l'idée.

    InformationsquelleAutor fastcodejava
  11. 0

    Tout d'abord le if.. then .. else est mieux, pour de multiples raisons l'ont souligné les autres affiches.

    Cependant, il n'est pas necceseraly plus vite! Il dépend entirly sur la ration des objets nuls pour ne pas null objets. Il prend sans doute une des centaines de milliers de fois les ressources pour le processus d'une exception plutôt que de tester la valeur null, cependant, si un objet nul ne se produit qu'une fois par million d'objets, puis l'exception de l'option sera légèrement plus rapide. Mais pas beaucoup plus rapide que sa vaut la peine de faire votre programme en moins lisible et plus difficile à déboguer.

    • -1 pour des informations incorrectes. Dans le compilateur JIT de l'Oracle Hotspot VM "Null vérifications peuvent être hissé à la main, et supprimer implicite null vérifie dans dominée blocs.", c'est à dire à la fois le si et l'essai d'approche d'effectuer le même nombre de vérifications. Par conséquent, si la version n'est jamais plus lent sur cette VM une fois que l'équipe a exécuter.
    InformationsquelleAutor James Anderson
  12. 0

    if-else est plus rapide, car un bloc try-catch soulève une trace de pile d'exception.
    Vous pouvez le prendre comme la Si-bloc Else est en cours d'exécution d'une instruction à procéder à l'évaluation, mais le Try-Catch sera exécuté des milliers d'instructions de lever l'exception quand il arrive.

    InformationsquelleAutor FearUs
  13. 0

    Ce problème a été discuté récemment par le Dr Heinz:

    http://javaspecialists.eu/webinars/recordings/if-else-npe-teaser.mov

    InformationsquelleAutor Radi