This action might not be possible to undo. Are you sure you want to continue?
JAVA Development tools What is JVM? JVM Architecture Execution Environment JAVA Bytecodes Bytecode Verifier Bytecode Instructions How does JVM work? JVM-a part of JRE Data types in JVM
JAVA DEVELOPMENT TOOLS
A virtual machine can be any platform-hardware or software-that is capable of understanding and executing Java bytecodes. There are currently three such platforms: Java Virtual Machines, Just-in-Time Compilers, and Java Processors. Java Virtual Machine The Java Virtual Machine is a piece of software that translates Java bytecodes to the processor's native opcodes as they are executed. Just-in-Time (JIT) compilers Interpreted languages are portable, but slow. Just-in-Time (JIT) compilers were invented to speed the execution of Java programs by speeding up the language translation process. It keeps a copy of all previously translated code for potential reuse. That way, the same section of code never has to be reinterpreted. Only new bytecodes that have not been previously executed need to be translated. Java processor Java processor is a microprocessor with a set of opcodes that are identical to the Java bytecode standard. To eliminate the need for native methods, these chips will have a set of extended bytecodes for accessing memory directly. It is reasonable to expect that these so-called JavaChips will execute Java bytecodes as quickly as any
What Is JVM?
The Java Virtual Machine, or JVM, is an abstract computer that runs compiled Java programs. All Java programs are compiled for the JVM. The Java Virtual Machine is a crucial component of the Java Platform. JVM is a platform-independent execution environment that converts Java bytecode into machine language and executes it. A JVM mimics a real Java processor, enabling Java bytecode to be executed as actions or operating system calls on any processor regardless of the operating system. A JVM is a set of computer software programs and data structures which implements a specific virtual machine model. The JVM is "virtual" because it is generally implemented in software on top of a "real" hardware platform and operating system. The Java Virtual Machine has a stack-based architecture
JVM Provides A Layer Of Abstraction Between The Compiled Java Program And The Underlying Hardware Platform And Operating System
COMPILED JAVA PROGRAMS JAVA VIRTUAL MACHINE
HARDWARE PLATFORM AND OPERATING SYSTEM
The behaviour of JVM implementation is defined in terms of subsystems,datatypes and instructions. These components form the architecture of JVM. Every implementation of Java has a class loader system and an execution engine. The class loader system is responsible for loading classes and interfaces in JVM. The execution engine is responsible for executing the methods of the loaded classes. JVM needs memory to store objects, parameters to methods, return values, or the result of any computation. It organizes this memory in data areas such as heaps, method areas and native method stacks. JVM components that implement security in the execution environment are the class loader, class file verifier,and
CLASS LOADER SUBSYSTEM
The part of a Java virtual machine implementation that takes care of finding and loading types is the class loader subsystem. The Java virtual machine has a flexible class loader architecture that allows a Java application to load classes in custom ways. A Java virtual machine's main job is to load class files and execute the bytecodes they contain. The Java virtual machine contains a class loader, which loads class files from both the program and the Java API.
Only those class files from the Java API that are actually needed by a running program are loaded into the virtual machine. The bytecodes are executed in an execution engine.
TYPES OF CLASS LOADERS
bootstrap class loader The bootstrap class loader (there is only one of them) is a part of the Java virtual machine implementation. The bootstrap class loader loads classes, including the classes of the Java API, in some default way, usually from the local disk. user-defined class loader a Java application can install user-defined class loaders that load classes in custom ways, such as by downloading class files across a network .
The class loader subsystem also does:
Loading: finding and importing the binary data for a type Linking: performing verification, preparation, and resolution
Verification: ensuring the correctness of the imported type Preparation: allocating memory for class variables and initializing the memory to default values Resolution: transforming symbolic references from the type into direct references.
Initialization: invoking Java code that initializes class variables to their proper starting values. Every Java virtual machine implementation has a bootstrap class loader, which knows how to load trusted classes, including the classes of the Java API. The Java virtual machine specification doesn't
JVM needs memory to store:
bytecodes parameters to methods return values local variables intermediate results of computations. The Java virtual machine organizes this memory it needs to execute a program into several runtime data areas.
Run Time Data Areas
The "virtual hardware" of the Java Virtual Machine can be divided into four basic parts:
The Registers The Stack The Garbage-collected Heap The Method Area.
•Each register in the JVM stores one 32-bit address. •The stack and garbage-collected heap are aligned on word (32-bit) boundaries. •The method area, because it contains bytecodes, is aligned on byte boundaries. •The size of an address in the JVM is 32 bits.The JVM can, therefore, address up to 4 gigabytes of memory, with each memory location containing one byte. •A word in the Java Virtual Machine is 32 bits. •Object handle is a 32-bit address that refers to an object on the heap.
The Method Area And The Program Counter
The method area is where the bytecodes reside. The program counter always points to some byte in the method area. The program counter is used to keep track of the thread of execution. After a bytecode instruction has been executed, the program counter will contain the address of the next instruction to execute. After execution, the JVM sets the program counter to the address of the instruction that immediately follows the previous one.
The Garbage-collected Heap
The heap is where the objects of a Java program live. Any time you allocate memory with the new operator, that memory comes from the heap. The runtime environment keeps track of the references to each object on the heap, And automatically frees the memory occupied by objects that are no longer referenced -- a process called garbage collection
The Java Stack And Related Registersis used The Java stack
to store parameters for and results of bytecode instructions, to pass parameters to and return values from methods, and to keep the state of each method invocation.
The state of a method invocation is called its stack frame. The vars, frame, and optop registers point to different parts of the current stack frame.
RUNTIME DATA AREAS EXCLUSIVE TO EACH THREAD
ere are three sections in a Java stack frame:
Contains All The Local Variables Being Used By The Current Method Invocation. It Is Pointed To By The Vars Register.
Is Used To Maintain The Operations Of The Stack Itself. It Is Pointed To By The Frame Register. Used As A Work Space By Bytecode Instructions.The Parameters For Bytecode Instructions Are Placed, And Results Of Bytecode Instructions Are Found Here. The Top Of The Operand Stack Is Pointed To By The Optop
At the core of any Java virtual machine implementation is its execution engine. In the Java virtual machine specification, the behavior of the execution engine is defined in terms of an instruction set. For each instruction, the specification describes in detail what an implementation should do when it encounters the instruction as it executes bytecodes. The term "execution engine" can also be used in any of three senses: an abstract specification, a concrete implementation, or a runtime instance. The abstract specification defines the behavior of an execution engine in terms of the instruction set. Concrete implementations, which may use a variety of techniques, are either software, hardware, or a combination of both. A runtime instance of an execution engine is a thread. Each
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. Multiple class files may be packaged together in a .jar file (short for Java archive). The JVM runtime executes .class or .jar files, emulating the JVM instruction set by interpreting it, or using a just-in-time compiler (JIT) such as Sun's HotSpot.
STEP 1 Java programs are compiled into a form called Java bytecodes. STEP 2 The JVM executes Java bytecodes, so Java bytecodes can be thought of as the machine language of the JVM.
STEP 3 The Java compiler reads Java language source (.java) files, translates the source into Java bytecodes, and places the bytecodes into class (.class) files.
STEP 4 The compiler generates one class file per class in the source.
To the JVM, a stream of bytecodes is a sequence of instructions. Each instruction consists of a one-byte opcode and zero or more operands. The opcode tells the JVM what action to take. If the JVM requires more information to perform the action than just the opcode, the required information immediately follows the opcode as operands. A mnemonic is defined for each bytecode instruction. The mnemonics can be thought of as an assembly language for JVM.
The JVM verifies all bytecode before it is executed. This verification consists primarily of three types of checks: Branches are always to valid locations Data is always initialized and references are always type-safe Access to "private" or "package" data and methods is rigidly controlled.
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 Monitor-based concurrency
How Does JVM Work?
Most programming languages compile source code directly into machine code, suitable for execution on a particular microprocessor architecture. The difference with Java is that it uses bytecode - a special type of machine code. Java bytecode executes on a special type of microprocessor. There wasn't a hardware implementation of this microprocessor available when Java was first released. Instead, the processor architecture is emulated by what is known as a "virtual machine". This virtual machine is an emulation of a real Java processor - a machine within a machine . The only difference is that the virtual machine isn't running on a CPU - it is being emulated on the CPU of the host machine.
JVM emulation run on a physical CPU
JVM-a part of JRE
The Java Virtual Machine forms part of a large system, the Java Runtime Environment (JRE). The JRE comprises a set of base classes, which are an implementation of the base Java API, as well as a JVM. Without an available JRE for a given environment, it is impossible to run Java software.
The JVM is responsible for interpreting Java bytecode, and translating this into actions or operating system calls.
JVM “ Lean And Mean ! “
The JVM is LEAN because it is small when implemented in software. It was designed to be small so that it can fit in as many places as possible -places like TV sets, cell phones, and personal computers.
The JVM is MEAN because it of its ambition. It wants to be everywhere, and its success is indicated by the extent to which programs written in Java will run everywhere.
DATA TYPES IN JVM
The JVM has a small number of primitive data types: The integral types are: ► byte ( 8 bits) ► short (16 bits) ► int (32 bits) ► Long (64 bits) ► char (16 bits). The floating types are: ► float (32 bits) ► double (64 bits)
The data types can be divided into a set of primitive types and a reference type. Variables of the primitive types hold primitive values, and variables of the reference type hold reference values. Reference values refer to objects, but are not objects themselves. Primitive values, by contrast, do not refer to anything.
All the primitive types of the Java programming language are primitive types of the Java virtual machine. Boolean qualifies as a primitive type of the JVM. When a compiler translates Java source code into bytecodes, it uses ints or bytes to represent booleans. In the JVM, false is represented by integer zero and true by any non-zero integer. Operations involving boolean values use ints. Arrays of boolean are accessed as arrays of byte. The primitive types of the Java programming language other than boolean form the numeric types of the Java virtual machine. The JVM works with one other primitive type that is unavailable to the Java programmer: the returnAddress type. It is used to implement finally clauses of Java programs.
Values of type reference come in three flavors: class type- references to class instances interface type- references to class instances that implement an interface array type- references to arrays, which are full-fledged objects in JVM. All three types have values that are references to dynamically created objects. One other reference value is the null value, which indicates the reference variable doesn't refer to any object.
DATA TYPES OF THE JAVA VIRTUAL MACHINE
byte short int long char float double
8-bit signed two's complement integer (-27 to 27 - 1, inclusive) 16-bit signed two's complement integer (-215 to 215 - 1, inclusive) 32-bit signed two's complement integer (-231 to 231 - 1, inclusive) 64-bit signed two's complement integer (-263 to 263 - 1, inclusive) 16-bit unsigned unicode character (0 to 216 - 1, inclusive) 32-bit IEEE 754 single-precision float 64-bit IEEE 754 double-precision float
The Java Virtual Machine provides a platform-independent way of executing code, by abstracting the differences between operating systems and CPU architectures. Java Runtime Environments are available for a wide variety of hardware and software combinations, making Java a very portable language. Programmers can concentrate on writing software, without having to be concerned with how or where it will run. The idea of virtual machines is nothing new, but Java is the most widely used virtual machine used today. Thanks to the JVM, the dream
This action might not be possible to undo. Are you sure you want to continue?
We've moved you to where you read on your other device.
Get the full title to continue reading from where you left off, or restart the preview.