09/17/10
19:02:28 1
09
CS 61B: Lecture 9
Friday, September 17, 2010
Today’s reading: Sierra & Bates pp. 77, 235-239, 258-265, 663.
THE STACK AND THE HEAP
======================
Java stores stuff in two separate pools of memory: the stack and the heap.
The _heap_ stores all objects, including all arrays, and all class variables
(i.e. those declared "static").
The _stack_ stores all local variables, including all parameters.
When a method is called, the Java Virtual Machine creates a _stack_frame_ (also
known as an _activation_record_) that stores the parameters and local variables
for that method. One method can call another, which can call another, and so
on, so the JVM maintains an internal _stack_ of stack frames, with "main" at
the bottom, and the most recent method call on top.
Here’s a snapshot of the stack while Java is executing the SList.insertEnd
method. The stack frames are on the left. Everything on the right half of the
page is in the heap. Read the stack from bottom to top, because that’s the
order in which the stack frames were created.
STACK | HEAP
|
method call parameters & local variables |
----------------------------------------------|
--- | -------------------
this |.+----------->|item |.| next |X|
SListNode.SListNode --- --- | -------+-----------
obj |.+--------------------------\ |
--- | | |
----------------------------------------------| v v
--- | ------------
obj |.+----------------------->| string |
--- | ------------
SList.insertEnd --- | ^
this |.+--------------------------+---------\
--- | | |
----------------------------------------------| | |
--- | | |
str |.+--------------------------/ v
--- --- | ---------------------
list |.+----------------->|head |X| size | 0 |
--- | ---------------------
SList.main --- | --------- -----------
args |.+------------------------>| . | .-+-->| words |
--- | --+------ -----------
| | -----------
----------------------------------------------| \--->| input |
-----------
The method that is currently executing (at any point in time) is the one whose
stack frame is on top. All the other stack frames represent methods waiting
for the methods above them to return before they can continue executing.
When a method finishes executing, its stack frame is erased from the top of the
stack, and its local variables are erased forever.
The java.lang library has a method "Thread.dumpStack" that prints a list of the
methods on the stack (but it doesn’t print their local variables). This method
can be convenient for debugging--for instance, when you’re trying to figure out
which method called another method with illegal parameters that made it crash.
Parameter Passing
-----------------
As in Scheme, Java passes all parameters _by_value_. This means that the
method has _copies_ of the actual parameters, and cannot change the originals.
The copies reside in the method’s stack frame for the method. The method can
change these copies, but the original values that were copied are not changed.
In this example, the method doNothing sets its parameter to 2, but it has no
effect on the value of the calling method’s variable a:
method: | STACK (just before method returns)
|
static void doNothing(int x) { | -----
x = 2; | x | 2 |
} | ----- stack frame for doNothing
|-----------------------------------------
method call: |
| -----
int a = 1; | a | 1 |
doNothing(a); | ----- stack frame for main
When the method call returns, a is still 1. The doNothing method, as its name
suggests, failed to change the value of a, or do anything relevant at all.
However, when a parameter is a reference to an object, the reference is copied,
but the object is not; the original object is shared. A method can modify an
object that one of its parameters points to, and the change will be visible
everywhere. Here’s an example that shows how a method can make a change to an
object that is visible to the calling method:
method: | STACK | HEAP
| set3|
class IntBox { | ----- |
public int i; | ib | .-+----------------\
static void set3(IntBox ib) { | ----- | |
ib.i = 3; | | |
} |--------------------| v
| ----- | ------
method call: | b | .-+------------->|i |3|
| ----- main| ------
IntBox b = new IntBox();
set3(b);
For those of you who are familiar with programming languages that have "pass
by reference," the example above is as close as you can get in Java. But it’s
not "pass by reference." Rather, it’s passing a reference by value.
Here’s an example of a common programming error, where a method tries and fails
to make a change that is visible to the calling method. (Assume we’ve just
executed the example above, so b is set up.)
method: | STACK | HEAP
| badSet4|
class IntBox { | ----- | ------
static void badSet4(IntBox ib) { | ib | .-+------------->|i |4|
ib = new IntBox(); | ----- | ------
ib.i = 4; | |
} |--------------------|
| ----- | ------
method call: | b | .-+------------->|i |3|
| ----- main| ------
badSet4(b);
