That's a pretty broad question--have you read any of the white papers that talk about it?
Nutshell version: by profiling the actual execution of bytecode the JIT can optimize for actual execution paths and generate corresponding native machine code.
posted 10 years ago
okay thank u..
i read in some book- in JVM architecture execution engine contains Interpreter and JIT compiler. why both interpreter and JIT compiler to convert Byte code into Mechine code? what are the tasks of interpreter and JIT ?
1. Read the next bytecode to be executed
2. Look at what the bytecode is and find the native machine instruction(s) that correspond to it
3. Execute the native machine instruction(s)
4. Go to step 1
That is simple, it works well, and it will run your Java program. But it's also inefficient, because looking up the native instruction(s) for every single bytecode to be executed costs processing time. So the JVM contains a second mechanism, the Just-In-Time compiler, which basically does this:
1. Read all the bytecodes for the method that needs to be executed
2. Convert all those bytecodes to native machine instructions
3. Execute the generated native machine instructions
After it has converted the bytecodes for a method to native machine instructions, the JVM remembers that native code, so that the next time the method has to be run, it can simply run the native instructions - it doesn't need to convert the bytecodes every time the method is run. This makes the program run much faster.
Also, the JIT performs lots of optimizations to generate native code that runs as fast as possible.