ch8.htm

JAVA Developing Professional JavaApplets

&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;}<BR>
<BR>
&nbsp;&nbsp;&nbsp;// Pop the top item off the stack...<BR>
&nbsp;&nbsp;&nbsp;public Integer pop() throws StackEmptyException
{<BR>
&nbsp;&nbsp;&nbsp;&nbsp;Integer I;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;synchronized(this) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Throw exception if stack
is empty...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (top &lt; 0)<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;throw
new StackEmptyException();<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Otherwise, return the top
item and decrement the top...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;I = s[top];<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;s[top] = null;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-top;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;&nbsp;return I;<BR>
&nbsp;&nbsp;&nbsp;}<BR>
<BR>
&nbsp;&nbsp;&nbsp;// List the contents of the stack...<BR>
&nbsp;&nbsp;&nbsp;public void list() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;synchronized(this) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;for (int i = 0; i &lt;= top;
++i)<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(i
+ &quot;: &quot; + s[i]);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;}<BR>
}</TT>
</BLOCKQUOTE>
<HR>
<P>
The code blocks in Listing 8.6 could just have easily been synchronized
with the stack Integer array <TT>s</TT>.
The results would be the same. However, you cannot synchronize
with the integer variable <TT>top</TT>.
The synchronized modifier works only with objects and classes;
variables, such as integers, are not proper synchronization types.
<H3><A NAME="NotifyandWait">Notify and Wait</A></H3>
<P>
Suppose that you wanted to change the TestStack class to be blocking.
That is, if you are invoking the <TT>pop()</TT>
method and there is nothing on the stack, then you should wait
until some other thread adds an element to the stack. However,
because the <TT>pop()</TT> method
is synchronized, you cannot wait inside that method without locking
out the thread that is going to add the element you need! What
you would like to do is wait inside the <TT>pop()</TT>
method but relinquish the TestStack object monitor so that other
threads can use the stack.
<P>
Fortunately, the designers of Java come to your rescue again!
The base Object class has several methods built into it for this
situation. Because these methods are part of the base class, they
are available for every class you create. The <TT>wait()</TT>
method provides the behavior you need for the <TT>pop()</TT>
problem just discussed. When it is called, the <TT>wait()</TT>
method releases the Object's monitor and simply waits until it
is notified. Notification occurs when another thread calls the
same Object's <TT>notify()</TT> method.
This causes the waiting thread to wake up and reacquire the monitor.
If the thread finds what it needs, it can leave the method and
release the lock; otherwise, it can call <TT>wait()</TT>
again.
<P>
Listing 8.7 shows modified methods of the TestStack class that
implement the blocking behavior just discussed. The <TT>pop()</TT>
method no longer throws an exception if the stack is empty. It
now waits until the <TT>push()</TT>
method calls <TT>notify()</TT> to
indicate that an item has been added to the stack. In this example,
the <TT>wait()</TT> method will wait
indefinitely for an item to be added to the stack. In the Queue
class developed in this chapter's project, you will see the use
of alternate <TT>wait()</TT> methods
that have time-outs associated with them.
<HR>
<BLOCKQUOTE>
<B>Listing 8.7. The TestStack class with a blocking </B><TT><B><FONT SIZE=1 FACE="Courier">pop()</FONT></B></TT><B>
method.<BR>
</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<TT>// Push an item onto the stack...<BR>
&nbsp;&nbsp;&nbsp;public synchronized void push(Integer item)
throws StackFullException {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Throw exception if stack
is full...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (top == s.length)<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;throw
new StackFullException();<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Otherwise increment the
top and add the item...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;++top;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;s[top] = item;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<B>notify</B>();&nbsp;&nbsp;&nbsp;//
Let pop know you got something...<BR>
&nbsp;&nbsp;&nbsp;}<BR>
<BR>
&nbsp;&nbsp;&nbsp;// Pop the top item off the stack...<BR>
&nbsp;&nbsp;&nbsp;public synchronized Integer pop() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Wait indefinitely if stack
is empty...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;while (top &lt; 0) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<B>wait</B>();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;catch (InterruptedException
e) { }<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;} // end while<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Otherwise, return the top
item and decrement the top...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Integer I = s[top];<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;s[top] = null;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-top;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return I;<BR>
&nbsp;&nbsp;&nbsp;}</TT>
</BLOCKQUOTE>
<HR>
<P>
Listing 8.8 shows the StackThread class that is modified to use
the blocking <TT>pop()</TT> method.
The <TT>run()</TT> method is a lot
simpler than before because it no longer has to sleep between
invocations of <TT>pop()</TT>. This
is done implicitly when it is waiting for the TestStack to change.
<HR>
<BLOCKQUOTE>
<B>Listing 8.8. The StackThread class modified to use the blocking
</B><TT><B><FONT SIZE=1 FACE="Courier">pop()</FONT></B></TT><B>
method.<BR>
</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<TT>// Thread that constantly reads the stack
and prints out<BR>
// the current top...<BR>
class StackThread extends Thread {<BR>
&nbsp;&nbsp;&nbsp;TestStack s;<BR>
&nbsp;&nbsp;&nbsp;public StackThread(TestStack s) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;this.s = s;<BR>
&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;// Loop forever, looking at the top of the stack...
<BR>
&nbsp;&nbsp;&nbsp;public void run() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Integer Top;<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;while (true) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Print
out top of stack, if stack isn't empty...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Wait
indefinitely if the stack is empty...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Top = s.pop();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;System.out.println(&quot;Thread:
Read &quot; + Top);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;}<BR>
}</TT>
</BLOCKQUOTE>
<HR>
<P>
If more than one thread is waiting on an object, the <TT>notifyAll()</TT>
method can be used to tell all waiting threads of the change in
the object's state. On the other hand, the <TT>notify()</TT>
method will send a signal only to a single waiting thread. It
should also be noted that the <TT>notify()</TT>
and <TT>wait()</TT> methods can be
called only from within a synchronized method and from the thread
that currently owns the object's monitor. For example, if the
StackApplet object tried to call the TestStack object's <TT>notify()</TT>
method, an IllegalMonitorStateException would be thrown.
<H2><A NAME="MoreAboutThreads"><FONT SIZE=5 COLOR=#FF0000>More
About Threads</FONT></A></H2>
<P>
Suppose you need one of your objects to sleep for a while, but
the object is not an instance of the Thread class. How can this
be done? The Thread class has a static method, called <TT>currentThread()</TT>,
that returns a reference to the Thread object currently being
executed. If the code is structured as in the following example,
you can get the Thread reference you need:
<BLOCKQUOTE>
<TT>public class MyClass {&nbsp;&nbsp;&nbsp;//
Note it does not extend Thread<BR>
&nbsp;&nbsp;&nbsp;public MyMethod() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// ...work for a while...
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Now sleep for 2 seconds
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Thread.currentThread().sleep(2000);
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// ...back to work...<BR>
&nbsp;&nbsp;&nbsp;}<BR>
}</TT>
</BLOCKQUOTE>
<P>
With the reference returned from <TT>currentThread()</TT>,
you can execute the Thread methods that your class needs to perform.
If you engage in serious Java programming, you will find the method
to be useful in a wide variety of situations.
<P>
Another feature of the Thread class is that threads can run at
different priority levels. Recall that threads generally operate
by using time-slicing. Setting the priority of a thread lets you
establish how large a time-slice your thread will get in relation
to other threads. For example, a high-priority thread will get
larger slices of time to process than a low-priority thread will.
The Thread class supplies three public variables that can be used
to define a thread's priority:
<UL>
<LI><TT>MIN_PRIORITY</TT> indicates
the minimum priority value in which a thread can run. A thread
set to this priority will receive little processing time. It is
best used for low-priority activities whose rate of completion
isn't important. In this context, it is worth noting that the
Java garbage collector runs at low priority (although it may not
be <TT>MIN_PRIORITY</TT>).
<LI><TT>NORMAL_PRIORITY</TT> indicates
the default value in which a thread runs. Most threads you create
will run at this priority.
<LI><TT>MAX_PRIORITY</TT> indicates
the maximum priority value in which a thread can run. A thread
running at this priority will take most of the available CPU time.
This should be used only for short CPU-intensive tasks that need
to finish quickly.
</UL>
<P>
In general, these priorities are set at the values of <TT>1</TT>,
<TT>5</TT>, and <TT>10</TT>,
respectively. However, it is best not to code with this knowledge
because these variable definitions exist to hide their underlying
values.
<P>
A thread's priority can be set with the <TT>setPriority()</TT>
method. This method takes an integer priority value as its sole
parameter. It throws an IllegalArgumentException if the priority
does not fall within the bounds of <TT>MIN_PRIORITY</TT>
and <TT>MAX_PRIORITY</TT>, inclusively.
For example, this code sets the priority of a thread to the minimum
value:
<BLOCKQUOTE>
<TT>// Create the thread...<BR>
myThread t;<BR>
t = new MyThread().<BR>
// Set the priority to minimum<BR>
try {<BR>
&nbsp;&nbsp;t.setPriority(Thread.MIN_PRIORITY);<BR>
}<BR>
// This exception will not occur!<BR>
catch (IllegalArgumentException e) {<BR>
&nbsp;&nbsp;System.out.println(e.getMessage());<BR>
}<BR>
// Start the thread at the low priority...<BR>
t.start();</TT>
</BLOCKQUOTE>
<P>
The priority of a thread can be retrieved with the <TT>getPriority()</TT>
method. Table 8.1 provides a summary of Thread class methods that
you may find useful. Note that ThreadGroups and daemons will be
discussed next.<BR>
<P>
<B>Table 8.1. Summary of important methods of the Thread class.</B>

<P><CENTER><TABLE BORDERCOLOR=#000000 BORDER=1  WIDTH=80%>
<TR VALIGN=TOP><TD WIDTH=175><TT><I>Method</FONT></I></TT>
</TD><TD WIDTH=415><I>Description</I></TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>currentThread()</TT>
</TD><TD WIDTH=415>Returns a reference to the currently executing Thread.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>getName()</TT>
</TD><TD WIDTH=415>Gets the name of the Thread. Assigned manually or automatically in the constructor.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>getPriority()</TT>
</TD><TD WIDTH=415>Returns the priority of a Thread.</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>GetThreadGroup()</TT>
</TD><TD WIDTH=415>Returns the ThreadGroup of a thread.</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>isAlive()</TT>
</TD><TD WIDTH=415>Returns whether the Thread is alive; that is, it has been started but not stopped.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>join()</TT>
</TD><TD WIDTH=415>Waits for a Thread to die.</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>resume()</TT>
</TD><TD WIDTH=415>Resumes the running of a suspended Thread.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>run()</TT></TD>
<TD WIDTH=415>Establishes where the threaded activity occurs.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>setDaemon()</TT>
</TD><TD WIDTH=415>Establishes the Thread as a daemon or user thread.
</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>setPriority()</TT>
</TD><TD WIDTH=415>Sets the priority of a Thread.</TD></TR>
<TR VALIGN=TOP><TD WIDTH=175><TT>sleep()</TT>
</TD><TD WIDTH