This preview shows page 1. Sign up to view the full content.
Unformatted text preview: ote objects. When these calls involve
passing parameters or accepting a return value, how does RMI transfer these between JVMs?
What semantics are used? Does RMI support pass-by-value or pass-by-reference? The answer
depends on whether the parameters are primitive data types, objects, or remote objects.
Parameters in a Single JVM
First, review how parameters are passed in a single JVM. The normal semantics for Java
technology is pass-by-value. When a parameter is passed to a method, the JVM makes a copy of
the value, places the copy on the stack and then executes the method. When the code inside a
method uses a parameter, it accesses its stack and uses the copy of the parameter. Values
returned from methods are also copies.
When a primitive data type (boolean, byte, short, int, long, char, float, or double) is passed as a
parameter to a method, the mechanics of pass-by-value are straightforward. The mechanics of
passing an object as a parameter are more complex. Recall that an object resides in heap
memory and is accessed through one or more reference variables. And, while the following code
makes it look like an object is passed to the method println()
String s = "Test";
in the mechanics it is the reference variable that is passed to the method. In the example, a copy
of reference variable s is made (increasing the reference count to the String object by one) and is
placed on the stack. Inside the method, code uses the copy of the reference to access the object.
Now you will see how RMI passes parameters and return values between remote JVMs. 12 Manisha Akolkar INTERNATIONAL INSTITUTE OF INFORMATION TECHNOLOGY
P-14, Pune Infotech Park, Hinjaw adi, Pune – 411 027
When a primitive data type is passed as a parameter to a remote method, the RMI system
passes it by value. RMI will make a copy of a primitive data type and send it to the remote
method. If a method returns a primitive data type, it is also returned to the calling JVM by value.
Values are passed between JVMs in a standard, machine-independent format. This allows JVMs
running on different platforms to communicate with each other reliably.
When an object is passed to a remote method, the semantics change from the case of the single
JVM. RMI sends the object itself, not its reference, between JVMs. It is the object that is passed
by value, not the reference to the object. Similarly, when a remote method returns an object, a
copy of the whole object is returned to the calling program.
Unlike primitive data types, sending an object to a remote JVM is a nontrivial task. A Java object
can be simple and self-contained, or it could refer to other Java objects in complex graph-like
structure. Because different JVMs do not share heap memory, RMI must send the referenced
object and all objects it references. (Passing large object graphs can use a lot of CPU time and
RMI uses a technology called Object Serialization to transform an object into a linear format that
can then be sent over...
View Full Document
- Summer '10