Java est vraiment lent?

initialement Java n'était pas particulièrement rapide, mais il n'est pas trop lent non plus. De nos jours, Java est très rapide. De la part des gens que J'ai parlé à L'impression que Java est lent vient de deux choses:

1. Slow VM startup time. La première implémentation Java a pris beaucoup de temps pour démarrer et charger les bibliothèques require et l'application par rapport aux applications natives.

2. Lenteur de l'INTERFACE utilisateur. Début Swing a été lente. Il n'a probablement pas aidé que la plupart des utilisateurs de Windows ont trouvé le L&F par défaut laid non plus.

compte tenu des points ci-dessus, il n'est pas étonnant que les gens ont eu L'impression que Java est lent.

pour les utilisateurs ou les développeurs habitués à développer des applications natives, ou même Visual Basic applications, ces deux points sont la chose la plus visible dans une application, et il est le première impression que vous obtiendrez au sujet d'une application (à moins que ce soit une application non-GUI dans lequel cas seulement le 1. appliquer.).

vous ne convaincrez pas un utilisateur que" il exécute le code très rapidement " lorsque l'application prend 8 secondes pour démarrer par rapport à son ancienne application Visual Basic qui démarre immédiatement - même si l'exécution du code et le temps de démarrage pourrait ne pas être connecté du tout.

ruiner la première impression est un excellent moyen de lancer des rumeurs et des mythes. Et les rumeurs et les mythes sont difficiles à tuer.

bref, Java n'est pas lent. Les gens qui ont "Java is slow attitude" sont basés sur les premières impressions de Java il y a plus de 10 ans.

après avoir lu une page pleine de commentaires disant que Java n'est pas lent, je dois juste répondre avec une opinion différente.

la lenteur d'une langue dépend beaucoup de ce que vous attendez de 'fast'. Si vous considérez que C# est rapide, Java est sûrement rapide aussi. Si votre domaine problématique est lié à des bases de données, ou à un traitement semi-réel, Java est sûrement assez rapide aussi. Si vous êtes heureux de mettre à l'échelle votre application en ajoutant plus de matériel, Java est probablement rapide pour vous. Si vous considérez qu'un facteur constant d'accélération dans l'échelle de 5-10 n'en vaut pas la peine, vous considérerez probablement Java fast.

si vous faites le calcul numérique sur de grands ensembles de données, ou sont liés à un environnement d'exécution, où les ressources CPU sont limitées, où une accélération constante dans l'échelle de 5-10 serait énorme. Même une vitesse de 0,5 pourrait signifier une réduction de 500 heures pour le calcul à compléter. Dans ces cas, Java ne vous permet tout simplement pas d'obtenir ce dernier mètre de performance, et vous considérerez probablement Java comme lent.

vous semblez poser deux questions assez différentes:

1. est-ce que Java est vraiment lent, et si oui pourquoi?
2. pourquoi Java est-il perçu comme lent, même s'il est plus rapide que plusieurs alternatives?

la première de ces questions est plus ou moins une question de "quelle longueur est une corde". Il s'agit de votre définition de "lent". Comparé à un pur interprète, Java est extrêmement rapide. Comparé à d'autres langues qui sont (normalement) compilé en une sorte de bytecode, puis compilé dynamiquement en code machine (par exemple C# ou n'importe quoi d'autre sur .NET). Par rapport aux langages qui sont normalement compilés avec du code machine pur, et qui ont (souvent de grandes) équipes de personnes travaillant sur rien d'autre que l'amélioration de leurs optimiseurs (par exemple C, C++, Fortran, Ada), Java fonctionne assez bien avec un quelques choses, mais dans l'ensemble a tendance à être au moins un peu plus lent.

est liée principalement à la mise en œuvre -- essentiellement, cela vient du fait qu'un utilisateur attend qu'un compilateur dynamique/JIT tourne, donc à moins que vous ayez un programme qui tourne pendant un certain temps pour commencer, il est difficile de justifier que le compilateur passe beaucoup de temps sur des optimisations difficiles. Par conséquent, la plupart de Java(et C#, etc.) les compilateurs ne mettent pas beaucoup d'efforts dans des optimisations vraiment difficiles. Dans la plupart des cas, il s'agit moins de ce que les optimisations sont faites que d'où elles viennent. appliquer. De nombreux problèmes d'optimisation sont NP complet, de sorte que le temps qu'ils prennent augmente rapidement avec la taille du problème étant attaqué. Une façon de garder le temps dans la raison est que l'optimisation de quelque chose comme une seule fonction à la fois. Quand c'est seulement le développeur qui attend le compilateur, vous pouvez vous permettre de prendre beaucoup plus de temps, et appliquer cette même optimisation à des parties beaucoup plus grandes du programme. De même, le code de quelques optimisations est assez chevelu (et peut donc être assez grand.) Encore une fois, puisque l'utilisateur attend que le code soit chargé (et le temps de démarrage de JVM est souvent un facteur important dans le temps global), la mise en œuvre doit équilibrer le temps gagné dans un endroit par rapport au temps perdu dans un autre -- et étant donné que peu de code bénéficie des optimisations velues, garder la petite JVM est généralement plus bénéfique.

un second problème est qu'avec Java, vous obtenez souvent une solution plus ou moins" Taille unique". Juste pour exemple, pour de nombreux Java developers Swing est essentiellement la bibliothèque de fenêtrage seulement disponible. Dans quelque chose comme C++, il y a littéralement des douzaines de bibliothèques de fenêtrage, de cadres d'application, etc., chacun avec son propre ensemble de compromis entre la facilité d'utilisation par rapport à l'exécution rapide, l'aspect et le toucher cohérent par rapport à l'aspect et le toucher natif, et ainsi de suite. Le seul point de friction réel est que certains (par exemple Qt) peuvent être très coûteux (au moins pour une utilisation commerciale).

troisième beaucoup de code écrit en C++ (et C encore plus) est simplement plus ancien et plus mature. Dans le lot, on trouve un noyau de routines écrites il y a plusieurs décennies, lorsque les dépenses de temps supplémentaire, l'optimisation du code est normal, le comportement attendu. Cela a souvent un réel avantage dans le code qui est plus petit et plus rapide. C++ (ou C) obtient le crédit pour le code étant petit et rapide, mais il est vraiment beaucoup plus un produit du développeur et les contraintes de l'heure le code a été écrit. Dans une certaine mesure, cela conduit à une prophétie auto-réalisatrice -- quand les gens se soucient de la vitesse, ils choisissent souvent C++ parce qu'il a cette réputation. Ils mettent plus de temps et d'efforts dans l'optimisation, et une nouvelle génération de code C++ rapide est écrite.

pour résumer, L'implémentation normale de Java rend au mieux l'optimisation maximale problématique. Pire, là où Java est visible , des choses comme les kits d'outils de fenêtrage et le temps de démarrage JVM jouent souvent un plus grand rôle que la vitesse d'exécution du langage lui-même de toute façon. Dans un grand nombre de cas, C et c++ obtiennent également le crédit pour ce qui est vraiment le produit de simplement travailler plus dur à l'optimisation.

quant à la deuxième question, je pense qu'il s'agit en grande partie d'une question de nature humaine au travail. Quelques fanatiques font des allégations plutôt exagérées sur Java étant aveuglément rapide. Quelqu'un l'essaie, et estime que, même trivial programme prend que quelques secondes pour commencer, et se sent lent et maladroit quand il fonctionne. Quelques probablement la peine d'analyser les choses à réaliser qu'une grande partie de ce temps est le temps de démarrage de la JVM, et le fait que lors de leurs premiers essais, aucun code n'a encore été compilé -- une partie du code est interprétée, et une partie est compilée pendant qu'ils attendent. Pire, même quand il fonctionne assez vite, l'apparence et la sensation semblera généralement étrangère et maladroite pour la plupart des utilisateurs, donc même si les mesures objectives ont montré des temps de réponse rapides, il semblerait encore maladroite.

ces additions conduisent à un assez simple et la réaction naturelle: que Java est lent, laid et maladroit. Étant donné le battage disant que c'est vraiment rapide, Il ya une tendance à réagir de façon excessive et de conclure penser à elle comme horriblement lent, au lieu d'un (plus précis) "légèrement plus lent, et que la plupart du temps dans des circonstances spécifiques."C'est généralement au pire pour un développeur écrit les premiers programmes dans la langue. L'exécution d'un programme" hello world " dans la plupart des langues semble instantanée, mais en Java il y a facilement pause perceptible au démarrage de la JVM. Même un interpréteur pur qui court beaucoup plus lentement sur des boucles serrées et telles apparaîtront encore souvent plus vite pour le code comme ceci, simplement parce qu'il peut être chargé et commencer à exécuter un peu plus tôt.

c'est une information dépassée des premiers jours (du milieu à la fin des années 1990) de Java. Chaque version majeure de Java a introduit des vitesses significatives par rapport à la version précédente. Oracle fusionnant apparemment JRockit avec la JVM de Sun pour Java 7, cette tendance devrait se poursuivre.

comparé à beaucoup d'autres langues modernes populaires (Python, Ruby, PHP), Java est en fait beaucoup plus rapide pour la plupart des utilisations. Il ne correspond pas tout à fait à C ou C++ mais pour beaucoup de tâches il est assez proche. Les vraies préoccupations de performance devrait être sur combien de mémoire il finit par utiliser.

le principal coupable du" long démarrage " est la liaison dynamique. Une application Java se compose de classes compilées. Chaque classe renvoie à d'autres classes (pour les types d'arguments, invocations de méthode...) par nom . La JVM doit examiner ces noms et les apparier au démarrage. Il le fait de façon graduelle, ne faisant que les parties dont il a besoin à un moment donné, mais il reste encore du travail à faire.

dans une demande C, que la phase de liaison se produit à la fin de la compilation. Il est lent, surtout pour les grandes applications, mais seul le développeur le voit. La liaison produit un fichier exécutable que le système D'exploitation doit simplement charger en RAM "tel quel".

en Java, le lien se produit chaque fois que l'application est lancée. D'où le temps de démarrage long.

Diverses optimisations ont été appliquées, y compris les techniques de mise en cache, et les ordinateurs sont plus rapides( et ils obtiennent "plus rapide" que les applications obtiennent "plus grand"), donc l'importance du problème a beaucoup diminué ces derniers temps, mais les vieux préjugés subsistent.

en ce qui concerne les performances postérieures, mes propres benchmarks sur les computations compactes avec accès réseau (principalement des fonctions de hachage et d'autres algorithmes cryptographiques) montrent généralement que le code C optimisé est environ 3x plus rapide que le code Java; parfois C est seulement 30% plus rapide que Java, parfois C peut être 4x plus rapide, selon l'algorithme mis en œuvre. J'ai vu un facteur 10x quand le code "C" était assemblé. pour les grands entiers arithmétiques, en raison de la multiplication 64x64->128 opcodes que le processeur offre mais Java ne peut pas utiliser parce que son plus long type entier est le 64-bit long . C'est un cas limite. Dans des conditions pratiques, des considérations d'E/S et de bande passante mémoire empêchent le code C d'être vraiment trois fois plus rapide que Java.

Java est certainement lent, surtout pour le travail quantitatif.

j'utilise une combinaison de R , Python et C/C++ avec des bibliothèques multithreaded optimisées ATLAS . Dans chacune de ces langues, je peux multiplier une matrice 3000 par 3000 de doubles avec elle-même en environ 4 secondes. En utilisant Colt et Parallel Colt en Java, la même opération prend 185 secondes! Étonnant malgré ces bibliothèques java étant parallèle dans la nature.

donc, somme toute, Le pur Java ne convient pas au travail quantitatif. Jblas semble être la meilleure bibliothèque d'algèbre linéaire pour Java car il utilise ATLAS.

ma machine est une HP Core 2 Duo avec 3 Go de RAM. J'utilise 64 bits Ubuntu 10.04 (Lucid Lynx).

pour l'expérience de la plupart des gens interagissant avec it - Java est lent. Nous avons tous vu cette tasse de café tourner sur notre navigateur avant qu'une applet ne se présente. Il faut un certain temps pour lancer la JVM et télécharger les binaires applet, et cela affecte l'expérience de l'utilisateur d'une manière qui est remarquée.

il ne sert à rien que le temps de téléchargement lent JVM spin-up et applet soit ostensiblement marqué avec une tasse de café Java, de sorte que les gens associent le attendre avec Java. Lorsque Flash prend beaucoup de temps à charger, la marque du message "loading" est spécifiée par le développeur Flash, de sorte que les gens ne blâment pas la technologie Flash dans son ensemble.

tout cela n'a rien à voir avec les performances de Java sur un serveur, ou dans les nombreuses autres façons dont Java est utilisé en dehors du navigateur. Mais c'est ce que les gens voient, et ce que les développeurs Non-Java se souviennent quand ils pensent à Java.

Java a la réputation d'être lent parce que était lent. Les premières versions de Java avaient soit pas ou plutôt pauvre juste dans le temps compilation. Cela signifie que le code, bien que bytecode, a été interprété, de sorte que même pour les opérations les plus simples (comme l'ajout de deux entiers) la machine a dû faire toutes sortes de comparaisons et de déréférences de pointeur et les appels de fonction. Le compilateur JIT s'est amélioré; maintenant c'est au point où si j'écris du code C++ négligemment et Code Java négligemment, Java va parfois outrepasser C++ parce que le compilateur JIT se rend compte que j'ai un déréférencement de pointeur inutile et prendra soin de lui pour moi.

si vous voulez voir à quel point une compilation JIT fait une grande différence, consultez les benchmarks interpreted vs. non-interpreted au Computer Languages Benchmark Game . (Pidigits utilise une bibliothèque externe pour faire tout le les calculs, pour que le benchmark ne change pas; les autres montrent une speedup 6-16x!)

Donc, c'est la raison principale. Il y a une variété d'autres raisons, moins importantes, qui n'ont pas aidé les choses: à l'origine, le temps de démarrage de Java était lent (maintenant fixé); les applications web en Java prennent beaucoup de temps à télécharger (beaucoup moins vrai maintenant avec large bande largement accessible, et avec de grandes choses comme des films étant attendus); le swing de L'interface utilisateur n'était pas (et n'est toujours pas) écrit avec la performance à l'esprit, il est donc beaucoup moins snappy que les équivalents en C++par exemple.

Java était lent, à l'époque. Il est devenu beaucoup plus rapide, en raison de quelques générations d'améliorations de performance . D'après ce que j'ai entendu, il est généralement à moins de 10% de la vitesse C# -- parfois plus rapide, parfois plus lent.

le démarrage de Java applet est encore lent parce qu'il faut démarrer toute une JVM, qui doit charger toutes ses classes. Un peu comme Démarrer un autre ordinateur. Une fois que le JVM démarre, il est assez rapide, mais le démarrage est généralement ce que des gens se souviennent.

il y a aussi au moins quelques personnes qui ne croiront jamais en la viabilité de Java.

Stefano:

j'ai été avec Java depuis le début, donc de mon point de vue la célébrité d'être lent a été créée par des interfaces graphiques lents et non réactifs (AWT, puis Swing) et dans des Applets probablement en raison des temps de démarrage lents supplémentaires des VM.

Java a stipulé et promu beaucoup de recherche dans le domaine de la VM, et il y a eu beaucoup d'améliorations, y compris la collecte des ordures (vous pouvez accorder beaucoup de les choses en fait; cependant, je vois souvent des systèmes où seulement par défaut sont utilisés) et l'optimisation hotspot (qui au début et est probablement encore plus efficace du côté du serveur).

Java à l'arrière-plan et le calcul n'est pas lent. Colt est l'un des meilleurs exemples:

la dernière version stable de Colt brise la barrière de 1,9 Gflop / s sur JDK ibm-1.4.1, RedHat 9.0, 2x IntelXeon@2.8 GHz.

il y a beaucoup de choses en dehors de Java mainstream qui devraient être considérées, comme Java en temps réel ou des mécanismes spéciaux pour améliorer la vitesse comme Javolution , ainsi que la compilation en avance sur le temps (comme gcj). En outre, il ya des IC qui peuvent exécuter Java Bytecode directement, comme par exemple celui qui est dans les iPhones et iPods actuels ARM Jazelle .

je pense qu'aujourd'hui c'est généralement une décision politique (comme Pas de support Java sur l'iPhone/iPod), et une décision contre Java en tant que langue (parce que beaucoup pensent qu'il est trop verbeux).

cependant, il existe de nombreux autres langages pour la VM Java de nos jours (par exemple Python, Ruby, JavaScript, Groovy, Scala, etc.) qui peut être une alternative.

personnellement, je continue à l'apprécier comme une plate-forme flexible et fiable, avec un excellent outillage et la disponibilité de la bibliothèque, qui permet de travailler avec tout, du plus petit appareil (par exemple JavaCard) aux plus gros serveurs.

un marteau est beaucoup plus lent à rouler la pâte que beaucoup d'autres outils. Ne pas faire le marteau "plus lent", ni moins utile pour les tâches qu'il est conçu pour faire.

en tant que langage de programmation général, Java est sur un pied d'égalité avec beaucoup (si ce n'est la plupart) pour un large éventail de tâches de programmation. Il existe des tests spécifiques et triviaux pour lesquels Java ne dépassera pas les solutions codées à la main dans des langages moins sophistiqués, ceux qui sont "plus proches du métal".

mais quand il s'agit des" applications du monde réel", Java est souvent le bon outil. Cela dit, rien n'empêchera les développeurs de faire une solution lente en utilisant N'importe quel outil. L'utilisation abusive de l'outil est un problème bien connu (il suffit de regarder les réputations de PHP et VB). Cependant, la conception et la syntaxe propres de Java (pour la plupart) font beaucoup pour réduire les abus.

Java est un langage de haut niveau et sa réputation aujourd'hui est d'avoir des performances sur un pied d'égalité avec d'autres langues de haut niveau comparables.

1. Il a de liaison dynamique de la sémantique. Par rapport au C++ où les méthodes non-virtuelles sont compilées comme des appels de fonction, même le meilleur compilateur Java du monde doit produire du code qui est moins efficace. Mais c'est aussi plus propre, plus sémantique.

2. Je ne me souviens pas des détails, mais j'ai entendu dans les premiers jours de Java qu'il y avait un mutex par objet Java, à acquérir et à libérer par chaque méthode. Cela tend à le rendre mieux adapté à la concurrence, bien que malheureusement juste un mutex par objet ne vous protégera pas des races ou des blocages ou toutes les mauvaises choses qui peuvent se produire dans les programmes concurrents. Cette partie, si elle est vraie, est un peu naïve, mais elle vient de bonnes intentions. Se sentir libre pour me renseigner sur la détails si vous en savez plus sur cet aspect.

3. une autre façon dont Java est un langage de haut niveau est d'avoir la collecte des ordures . La collecte des ordures peut être plus lente que malloc et free pour les programmes qui allouent à la fois toute la mémoire dont ils ont besoin et travaillent avec cela. Le problème est, dans les langues qui n'ont pas de collecte des ordures, les programmeurs ont tendance à écrire seulement programmes qui allouer toute la mémoire dont ils ont besoin à la fois et échouer s'il s'avère qu'une constante de taille maximale arbitraire a été dépassée. Donc la comparaison est des pommes et des oranges. Quand les programmeurs font l'effort d'écrire et de déboguer des programmes avec allocation dynamique de structures enchaînées dans des langues autres que le GC, ils trouvent parfois que leurs programmes ne sont plus plus plus rapides que dans un langage GC, parce que malloc et free ne sont pas gratuits! Ils ont aussi des frais généraux... De plus, ne pas avoir de forces GC à spécifier qui libère quoi, et avoir à spécifier qui libère quoi à son tour vous oblige parfois à faire des copies - quand plusieurs fonctions vont avoir besoin des données et qu'il n'est pas clair qui va les utiliser en dernier - alors que la copie n'aurait pas été nécessaire dans un langage GC.

au milieu des années quatre-vingt-dix, lorsque Java a fait son apparition, le c++ était le langage dominant, et le web était encore relativement nouveau. En outre, les MVC et la GC étaient des concepts relativement nouveaux dans le développement général. Les premières JVM étaient un peu lentes (par rapport au C++ fonctionnant sur du métal nu) et souffraient également de longues pauses de collecte des ordures, ce qui a conduit à une réputation de Java étant lent.

de nombreuses applications Java desktop (ces temps-ci: choses comme Eclipse) ont une mauvaise réactivité GUI, probablement en raison de la forte consommation de mémoire et le fait que classloader peut faire beaucoup D'IO. C'est mieux, mais était pire que de quelques années.

beaucoup (la plupart) de gens aiment faire des généralisations donc ils disent "Java est lent" parce qu'ils perçoivent les applications sont lents quand ils interagissent avec eux.

le problème majeur avec les applications java est qu'il est énorme en raison de la Grande Taille de la bibliothèque stock runtime. Les programmes énormes remplissent beaucoup de mémoire et ont tendance à échanger, ce qui signifie qu'ils deviennent lents.

la raison pour laquelle le Sun JVM est grand est qu'il dispose d'un très bon interpréteur de code octet qui fonctionne en gardant la trace de beaucoup de choses. Cela signifie beaucoup de données, ce qui signifie Mémoire.

Vous pouvez regarder le jamvm machine virtuelle qui est un interpréteur assez rapide (Pas de code natif) et très petite. Il démarre même vite.

comme le dit Pascal, Java est sur un pied d'égalité avec les autres langues de haut niveau. Cependant, comme quelqu'un qui a travaillé avec les JVM originales sur Windows 98 , à l'époque le niveau d'abstraction fourni par la machine virtuelle Java était, disons, douloureux.

fondamentalement, c'était l'émulation logicielle avec peu ou pas d'optimisation que nous tenons pour acquis aujourd'hui dans la JVM.

les gens passent normalement la ligne" c'est interprété". Parce qu'il était une fois, il l'était, et la mauvaise presse est transmise par des gens qui ont abandonné Java comme "trop lent" et ne sont jamais revenus pour tester de nouvelles versions.

ou peut-être "les gens sont idiots" est une meilleure réponse.

je pense qu'un jour, peut-être pas dans un avenir trop proche, les langages compilés par JIT seront plus performants que les langages compilés sous n'importe quel aspect (bien, peut-être pas le temps de démarrage/la consommation de mémoire) en raison du fait que les compilateurs JIT peuvent faire un usage intensif du comportement d'exécution et de la plate-forme sur laquelle ils tournent.