Est Java bytecode interprété?
La définition de l'interprétation (corrigez-moi si je me trompe) est un code d'analyse comme si:
1 - Traduire actuellement la ligne analysée vers une langue intermédiaire. 2 - Exécuter la ligne traduite. - Passez à la ligne suivante. 4 - Traduisez-le. 5 - Run It. Etc.
Si tel est le cas, pourquoi les gens disent-ils que le JVM interprète le Java bytecode? Qu'est-ce que cela fait est exécuter. Le bytecode est déjà traduit. Java code source, il n'est donc pas nécessaire de traduire davantage.
Que pourquoi est le terme interprétation impliqué?
Si ce terme est utilisé parce que le JVM exécute le bytecode -ligne par ligne, je dirais que toute exécution fait cela. Exécute le code runnable de haut en bas. Que pourquoi utiliser le terme interprétation?
interprétation par opposition à quoi?
Un processeur exécute instructions de la machine. Ils sont la seule chose qu'un processeur comprend.
Java Bytecode est une manière intermédiaire, compacte et compacte de représenter une série d'opérations (désireuse d'un meilleur terme). Le processeur ne peut pas Exécutez-les directement.
Le Java machine virtuelle traite ce flux d'opérations de byTecode et les interprète dans une série d'instructions de machine pour le processeur à exécuter.
Ceci est un processus très similaire à celui de celui que le Python interpréter fonctionne sur une entrée Python script. Peu importe que Java bytecode est un format binaire pour aider à accélérer l'exécution, et a Python script est un fichier texte. Même Python traite .PY Modules dans un binaire .pyc forme pour la même raison. La différence la plus fondamentale est que Java Bytecode a traversé une méthode d'étape de pré-traitement plus approfondie des appels d'objets, de la vérification des types, etc., de sorte que le JVM n'a alors pas à les faire.
Ceci VM Process est ce qui permet à Compiled Java= d'être portable à n'importe quel ordinateur, qu'il dispose d'un processeur X86, ARM Ou quelque chose d'autre - tant qu'il existe une JVM pour cette plate-forme. Les différentes versions de la JVM n'interprètent tous le même bytecode, mais produisent les instructions de la machine appropriées pour leur processeur.
Pour plus de détails, et une excellente explication sur la différence entre une machine virtuelle comme Java et un interprète comme CPPHon, voir la réponse acceptée ici:
https://stackoverflow.com/questions/441824/java-virtual-machine-vs-python-interpreter-parlance
La définition de l'interprétation (corrigez-moi si je me trompe) est un code d'analyse comme si:
- Traduisez la ligne actuellement analysée vers une langue intermédiaire.
- Exécutez la ligne traduite.
- Passer à la ligne suivante.
- Traduis le.
- Exécuter. Etc.
Ce n'est pas une définition valide. Il décrit simplement d'une manière de la mise en œuvre d'un interprète, mais elle exclut les autres moyens. La plupart des interprètes ne fonctionnent pas une ligne à une heure comme celle-là. Il est plus normal de traduire du code source à une forme intermédiaire avant d'essayer d'exécuter la forme intermédiaire.
Et même la phrase "forme intermédiaire" est potentiellement incorrecte, en ce sens qu'elle suggère qu'il existe une autre forme pour le code après la forme intermédiaire.
Si oui, pourquoi les gens disent que le JVM interprète le Java bytecode? Qu'est-ce que cela fait est l'exécuter.
L'interprétation est une forme d'exécution. Donc, il n'y a pas de contradiction.
Interprétation par opposition à quoi?
Par opposition à la compilation des bytecodes au code natif et d'exécuter le code natif. Qui est ce que typiquement se produit dans typique Java des implémentations ... d'une manière ou d'une autre.
Dans un typique JVM, les bytecodes sont interprétées pour commencer par. Après un bit, le compilateur JIT les compile au code natif pouvant être exécuté directement. Les autres modes incluent:
- Interpréter la bytecode tout le temps; par exemple. à l'aide de
Java -int - Devant la compilation de temps; par exemple. en utilisant
gcj. - Compilation de chargement ... dans laquelle les bytecodes sont compilées au code natif car elles sont chargées par le chargeur de classe; par exemple. Jnode fait cela.
Question de suivi
JIT Exécution signifie compiler chaque ligne pendant l'exécution, corriger? Si oui, comment est-ce différent de l'interprétation?
Premièrement, non ce n'est pas correct:
Il n'y a pas de "jit exécution". Quand les gens disent cela, ils signifient vraiment "la compilation et l'exécution" JIT "... et ils ne l'orthographient pas.
La compilation JIT n'a pas fait une ligne à la fois. Il est généralement fait une méthode à la fois.
Et la différence est dans ce qu'elle fait. Le travail de JIT Compiler doit compiler des byTecodes au code natif. Il n'exécute pas les bytecodes. L'exécution des bytecodes est effectuée en interprétant les bytecodes (avant qu'elles aient été compilées JIT) ou en exécutant le code natif que le compilateur JIT a produit.
Cela dépend de la mise en œuvre.
Java bytecode n'est pas la même chose que le code de la machine. C'est un format très similaire à celui utilisé par la plupart des architectures, ce qui le rend relativement facile à traduire en machine, mais je ne suis au courant d'aucun machines qui le courent réellement de manière native.
The Java spécifiques ne vous souciez pas de la manière dont le code est exécuté, tant que les résultats sont ce que la spécification dit qu'ils devraient être. Mais si vous ne l'exécutez pas de manière native, Ensuite, vous devez le traduire d'une manière ou d'une autre. Vous peut Faites cela avec interprétation, et c'est comme ça que certains JVM précoces ont fonctionné, mais cette technique est tombée de la faveur plus récente. De nos jours, il est plus courant de le compiler au code natif, à l'avance ou juste à temps, puis exécutez-le au lieu du bytecode.
Interprétation: Cela signifie que vous prenez un petit morceau de code, déterminez ce qu'il fait et puis le faire. Le petit morceau de code peut être un code source "texte brut", mais il peut également s'agir d'une sorte de code pré-jobé, ou d'une sorte de code d'octet ou d'instructions natives pour une CPU différente. La différence importante ici est que, pour interpréter son ne jamais converti en code natif pour la CPU, elle fonctionne.
Compilation: Cela signifie que vous convertissez le code source en code natif. Lorsque la plupart des gens pensent de "compilateurs", ils pensent à un outil convertit le code de source de texte brut en code natif (appelé "à l'avance de la compilation de temps" car il est compilé avant sa course - souvent avant que l'utilisateur final ne le reçoit), mais Ce n'est pas le seul moyen de compiler. Le principal avantage de la compilation de temps à l'avance est que le compilateur peut dépenser beaucoup de temps à optimiser le code sans que l'utilisateur final se souciait de votre temps.
JIT Compildicing: C'est l'un des différents cas de compilation (note: JIT est "juste à temps", et différentes personnes appelleront cette traduction dynamique). Dans ce cas, vous attendez que un petit morceau de code doit être exécuté, puis compilez cette petite pièce dans un code natif et l'exécuter; Ensuite, vous recherchez le prochain petit morceau de code. En mettant en cache les petits morceaux précédemment compilés, vous finissez par la compilation de la majeure partie du programme pendant que le programme est exécuté. Pour le code qui est exécuté souvent, cela est beaucoup plus rapide que l'interprétation; Mais pour le code qui est exécuté seulement une fois qu'il est plus lent que l'interprétation.
Pour Java, le code source de texte brut est compilé dans le code d'octet à l'aide d'un compilateur à l'avance. C'est là que beaucoup d'optimisation se produisent. Après cela, le code d'octet est exécuté par A Java machine virtuelle (JVM).
Les anciennes implémentations de JVMS utilisées pour interpréter le code d'octet (qui était plus lente). Les JVM modernes interprètent l'octet-code qui n'est pas exécuté très souvent (pour éviter la compilation de la compilation lorsqu'elle n'est pas justifiée) et que JIT compilent pour le code exécuté souvent (pour se rapprocher de la vitesse native pour ces parties plus importantes).
Fondamentalement (pour les implémentations modernes), ce n'est pas l'un ou l'autre - c'est "à l'avance" suivi d'un mélange d'interprétation interprétée et de compilation JIT.
La définition de l'interprétation (corrigez-moi si je me trompe) est un code d'analyse comme si:
1- Traduire actuellement la ligne analysée vers une langue intermédiaire. 2- Exécutez la ligne traduite. 3- passer à la ligne suivante. 4- Traduisez-le. 5- Run ça. Etc.
Je dirais que votre définition de "interprétation" est fausse - il n'y a pas (nécessairement) une étape de traduction dans l'interprétation. Donc, il devrait être:
- Lire un morceau de code
- Exécuter ce morceau de code
- Lire la prochaine partie du code
- Exécuter le prochain chunk
- ...continue
Dans le cas d'un interprète JVM ByTecode, un "chunk" est un seul bytecode. Dans une langue interprétée plus traditionnelle, un "chunk" pourrait être une ligne. L'étape "EXECUTE" pourrait impliquer de générer une partie de l'IL pour le morceau, puis d'interpréter que IL - dans quel cas vous avez deux interprètes, un niveau élevé qui invoque le niveau inférieur un.
Java Bytecode est une langue. Les langues ne sont pas interprétées ou compilées. Ils juste sont. L'interprétation et la compilation sont des traits de, eh bien, l'interprète ou le compilateur (DUH!), C'est-à-dire une mise en œuvre de cette langue.
Il existe une implémentation interprétée de la JVM (par exemple, des versions précoces de Sun JVM avant Java 1.2), il existe des implémentations compilées de la JVM (par exemple, des versions précoces de Maxine), mais la mise en œuvre la plus couramment utilisée). Le Sun/Oracle HotSpot JVM est en fait: il interprète d'abord le bytecode, la collecte de statistiques, puis compose les parties critiques de performance utilisant des informations d'optimisation dérivées de ces statistiques.