CODEWITHSUNDEEP
java
isha
isha

Reputation: 61

Java bytecode interpreter

i know that java programs are first compiled and a bytecode is generated which is platform independent. But my question is why is this bytecode interpreted in the next stage and not compiled even though compilation is faster than interpretation in general??

Upvotes: 4

Views: 6931

Answers (5)

Saurabh Gokhale
Saurabh Gokhale

Reputation: 46425

Byte code is platform independent. Once compiled into bytecode, it could run on any system.

As it says on Wikipedia,

Just-in-time compilation (JIT), also known as dynamic translation, is a method to improve the runtime performance of computer programs.

I recommend you to read this article. Its gives the basic working of JIT compiler for Java VM.

JIT compilers alter the role of the VM a little by directly compiling Java bytecode into native platform code, thereby relieving the VM of its need to manually call underlying native system services. The purpose of JIT compilers, however, isn't to allow the VM to relax. By compiling bytecodes into native code, execution speed can be greatly improved because the native code can be executed directly on the underlying platform.

When JIT compiler is installed, instead of the VM calling the underlying native operating system, it calls the JIT compiler. The JIT compiler in turn generates native code that can be passed on to the native operating system for execution. The primary benefit of this arrangement is that the JIT compiler is completely transparent to everything except the VM.

Upvotes: 0

Amir Raminfar
Amir Raminfar

Reputation: 34179

You answered your own question. Byte code is platform independent. If the compiled code was executed then it would not work on every OS. This is what C does and it is why you have to have one version for every OS.

As others have suggested, the JVM does actually compile the code using JIT. It is just not saved anywhere. Here is a nice quote to sum it up

In a bytecode-compiled system, source code is translated to an intermediate representation known as bytecode. Bytecode is not the machine code for any particular computer, and may be portable among computer architectures. The bytecode may then be interpreted by, or run on, a virtual machine. The JIT compiler reads the bytecodes in many sections (or in full rarely) and compiles them interactively into machine language so the program can run faster

Upvotes: 3

NPE
NPE

Reputation: 500883

The basic premise of your question is not true. Most modern Java virtual machines do compile frequently-executed parts of the code into native machine code.

This is known as just-in-time compilation, or JIT for short.

A pretty good introduction to relevant Sun's (now Oracle's) technology can be found here.

Upvotes: 1

mikera
mikera

Reputation: 106401

The Java bytecode normally is compiled via Just-In-Time (JIT) compilation.

So you still end up with fully compiled native code being executed, the only difference is that this native code is generated by the JVM at runtime, rather than being statically generated at the time the source code is compiled (as would happen with C/C++).

This gives Java two big advantages:

  • By delaying the compilation until runtime, the bytecode remains fully portable across platforms
  • In some cases the JIT compiler can actually generate more optimised native code because it is able to exploit statistics gathered by examining the execution parths of the code at runtime.

The downside, of course, is that the JIT compiler needs to do it's work at application start-up, which explains why JVM applications can have a slightly long start-up time compared to natively compiled apps.

Upvotes: 2

phlogratos
phlogratos

Reputation: 13924

The JVM uses Just in time compilation http://en.wikipedia.org/wiki/Just-in-time_compilation, so it's much faster than pure interpretation.

Upvotes: 0

Related Questions