Java virtual machine
|
|
A Java virtual machine or JVM is a virtual machine that runs Java byte code. This code is most often generated by Java language compilers, although the JVM has also been targeted by compilers of other languages.
The JVM is a crucial component of the Java platform. The availability of JVMs on almost all types of hardware and software platforms enables Java to function both as middleware and a platform in its own right. Hence the expression "Write once, run anywhere."
Programs intended to run on a JVM must be compiled into a standardized portable binary format, which typically comes in the form of .class files. A program may consist of many classes, in which case, every class will be in a different file. For easier distribution of large programs, multiple class files may be packaged together in a .jar file.
This binary is then executed by the JVM runtime which carries out emulation of the JVM instruction set by interpreting it or by applying a just-in-time Compiler (JIT) such as Sun's HotSpot.
The JVM has a stack based architecture. Each thread has its own stack and program counter.
The JVM verifies all bytecode before it is executed. This means that only a limited amount of bytecode sequences form valid programs, e.g. a JUMP (branch) instruction can only target an instruction within the same function. Because of this, the fact that JVM is a stack architecture does not imply a speed penalty for emulation on register based architectures when using a JIT compiler: in the face of the code-verified JVM architecture, it makes no difference to a JIT compiler whether it gets named imaginary registers or imaginary stack positions that need to be allocated to the target architectures registers. In fact, code verification makes the JVM different from a classic stack architecture whose efficient emulation with a JIT compiler is more complicated and typically carried out by a slower interpreter.
Code verification also ensures that arbitrary bit patterns cannot get used as an address. Memory protection is achieved without the need for an MMU. Thus, JVM is an efficient way of getting memory protection on simple silicon that has no MMU.
The JVM has instructions for the following groups of tasks
- Load and store
- Arithmetic
- Type conversion
- Object Creation and Manipulation
- Operand stack management (push / pop)
- Control transfer (branching)
- Method invocation and return
- Throwing exceptions
The aim is binary compatibility. Each particular host operating system needs its own implementation of the JVM and runtime. These JVMs interpret the byte code semantically the same way, but the actual implementation may be different. More complicated than just the emulation of bytecode is compatible and efficient implementation of the Java core API which has to be mapped to each host operating system.
The specification for the JVM is published in book form [1] (http://java.sun.com/docs/books/vmspec/2nd-edition/html/VMSpecTOC.doc.html), known as "blue book", and anybody is allowed to write an implementation of it. The preface states:
- We intend that this specification should sufficiently document the Java Virtual Machine to make possible compatible clean-room implementations. Sun provides tests which verify the proper operation of implementations of the Java Virtual Machine.
Kaffe is an example of a clean-room Java implementation. Sun retains control over the Java trademark, which it uses to certify implementation suites as fully compatible with Sun's specification.
Secure execution of remote code
A virtual machine architecture allows very fine-grained control over the actions that code within the machine is permitted to take. This allows safe execution of untrusted code from remote sources, a model used most famously by Java applets. Applets run within a VM incorporated into a user's browser, executing code downloaded from a remote HTTP server. The remote code runs in a highly restricted "sandbox", which protects the user from misbehaving or malicious code. Publishers can apply for a certificate with which to digitally sign applets as "safe", giving them permission to break out of the sandbox and access the local filesystem and network, presumably under user control.
Virtual machine implementations
Proprietary:
Open source:
- AegisVM [4] (http://aegisvm.sourceforge.net/)
- IKVM.NET [5] (http://www.ikvm.net/)
- GCJ [6] (http://gcc.gnu.org/java/)
- Jamiga [7] (http://sourceforge.net/projects/jamiga)
- JamVM
- Jaos [8] (http://www.oberon.ethz.ch/jaos/)
- JC [9] (http://jcvm.sourceforge.net/)
- Jikes RVM [10] (http://jikesrvm.sourceforge.net/)
- JNode [11] (http://jnode.sourceforge.net/)
- Jupiter JVM [12] (http://www.eecg.toronto.edu/~doylep/jupiter/)
- Kaffe
- Kissme [13] (http://kissme.sourceforge.net/)
- ORP [14] (http://www.intel.com/research/mrl/orp/)
- SableVM
External links
- List of languages (http://www.robert-tolksdorf.de/vmlanguages.html) which compile to the Java virtual machine.
- Sun.com - The Java Virtual Machine Specification (http://java.sun.com/docs/books/vmspec/)
- Kaffe.org - the Kaffe project (http://www.kaffe.org/)
- The lean, mean, virtual machine - An introduction to the basic structure and functionality of the Java Virtual Machine (http://www.javaworld.com/javaworld/jw-06-1996/jw-06-vm.html)de:Java Virtual Machine
fr:Machine virtuelle Java hu:Java virtuális gép nl:Java Virtual Machine ja:Java仮想マシン pl:Wirtualna maszyna Javy pt:Máquina virtual Java