JVM

Java Virtual machine -is an abstract computing machine. It is the component of java technology that gives it hardware and OS independence. It has its own instruction set and manipulates various memory areas at run time.

The architecture as defined in the specification makes it possible to have different JVM implementation for different hardware platforms.The architecture of the JVM as defined in the specification is shown in the diagram below

It consists of

1. Class Loader subsystem
2. Run time data areas
3. Execution engine
4. Native method interface
5. Native method libraries.

Class loader subsystem - is responsible for loading types (classes and interfaces). The .class files adhere to fix format and it contains JVM instructions or byte codes, a symbol table and other ancillary information.

Execution engine - is responsible for the actual execution of the instructions contained in the method of the loaded classes.

Run time data areas - the JVM organizes the memory it needs to execute a programs into various data areas. These various data areas may be shared by all the threads in the program or some data areas may be thread specific

• The method area and heap is shared by all the threads
• where as the PC registers,java stack, native method stack are thread specific.

Each instance of JVM has one memory area and one heap.

• Method area: holds the details of each class loaded by the class loader subsystem.
• Heap: holds every object being created by the threads during execution, including the main thread.

As each thread executes in the JVM, it gets its own PC register and the java stack. They are not shared among threads.

• PC registers: For any executing thread the register holds the address of the next instruction to execute.
• Java Stack: the stack stores the state of the method invocation (state - includes the local variables, the method parameters, the return value if any and intermediate or temporary calculations) of the thread (in stack frames - current execution method stack frame is the topmost)
• Native method stack : the state of the native method are stored in native method stacks in an implementation dependent way, so also possibly the registers or an other implementation dependent memory areas.

More on class loader subsystem in my next blog.

You can find useful references

http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html

http://www.artima.com/insidejvm/ed2/jvm.html