ch8.htm

JAVA Developing Professional JavaApplets

<P>
It is easy to modify the example to have multiple line-drawing
threads. If you add the following code, there will be two threads
drawing lines on the applet:
<BLOCKQUOTE>
<TT>Thread t2 = new LineThread(this);<BR>
t2.start();</TT>
</BLOCKQUOTE>
<P>
You should add corresponding <TT>stop()</TT>
and <TT>join()</TT> methods to terminate
the threads in the applet <TT>destroy()</TT>
method.
<H2><A NAME="TheRunnableInterface"><FONT SIZE=5 COLOR=#FF0000>The
Runnable Interface</FONT></A></H2>
<P>
One thing may strike you as troubling in this discussion about
how threads work. If you have to use the Thread class every time
you need to run something as a thread, don't you lose the capability
to inherit other classes? Because Java is a single-inheritance
system, forcing a class to inherit the Thread class would seem
to be overly restrictive because you couldn't, for example, run
the Applet class as a thread. Fortunately, Java actually implements
threads through an interface, thus allowing any class to use a
thread's functions. The interface is called <I>Runnable</I> and
has only one method, <TT>run()</TT>.
The <TT>run()</TT> method of the Thread
class is itself an implementation of Runnable.
<P>
The typical way of starting a class that implements Runnable as
a thread is to call an alternate Thread constructor. This constructor
takes a Runnable class as its target parameter. For example, if
you have a Runnable object assigned to the variable <TT>r</TT>,
you would pass it to the Thread constructor as follows:
<BLOCKQUOTE>
<TT>t = new Thread(r);</TT>
</BLOCKQUOTE>
<P>
When the thread's <TT>start()</TT>
method is called after this, the <TT>run()</TT>
method of the Runnable target is invoked. If you don't want to
explicitly declare a <TT>Thread</TT>
variable, you can start the Runnable target in a more concise
manner:
<BLOCKQUOTE>
<TT>new Thread(r).start();</TT>
</BLOCKQUOTE>
<P>
A Thread object created with a Runnable target behaves similarly
to the thread behavior discussed in the previous sections. The
<TT>stop()</TT> method terminates
the thread, <TT>suspend()</TT> and
<TT>resume()</TT> are used to pause
and restart the thread, and so on.
<P>
The line-drawing applet can be reworked to use the Runnable interface.
In the example shown in Listing 8.3, the LineThread class is removed,
and the Applet class (called LineRun, in this case) implements
the Runnable interface. Therefore, there is only one class in
the applet that both draws the lines and runs as a thread.
<HR>
<BLOCKQUOTE>
<B>Listing 8.3. The line-drawing applet using the Runnable interface.
<BR>
</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<TT>import java.awt.*;<BR>
import java.lang.*;<BR>
import java.applet.Applet;<BR>
<BR>
// Runs the Applet as a Thread so that it can paint<BR>
// lines indefinitely...<BR>
public class LineRun extends Applet implements Runnable {<BR>
&nbsp;&nbsp;&nbsp;Thread t;&nbsp;&nbsp;// This is the thread!
<BR>
&nbsp;&nbsp;&nbsp;// Set the size of the applet...<BR>
&nbsp;&nbsp;&nbsp;public void init() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;resize(300,300);
<BR>
&nbsp;&nbsp;&nbsp;}<BR>
<BR>
&nbsp;&nbsp;&nbsp;// Entering the Applet. Start the thread...
<BR>
&nbsp;&nbsp;&nbsp;public void start() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp; if (t == null) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t = new Thread(this);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.start();<BR>
&nbsp;&nbsp;&nbsp;&nbsp; } // end if<BR>
&nbsp;&nbsp;&nbsp;}<BR>
<BR>
&nbsp;&nbsp;&nbsp;// Leaving the Applet. Stop the thread...<BR>
&nbsp;&nbsp;&nbsp;public void stop() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp; if (t != null) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.stop();<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.join();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;catch (InterruptedException
e) { }<BR>
&nbsp;&nbsp;&nbsp;&nbsp; } // end if<BR>
&nbsp;&nbsp;&nbsp;&nbsp; t = null;<BR>
&nbsp;&nbsp;&nbsp;}<BR>
<BR>
&nbsp;&nbsp;&nbsp;// Run the thread. Lines everywhere!<BR>
&nbsp;&nbsp;&nbsp;public void run() {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Get dimension data about
the applet...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;double width = (double)size().width;
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;double height = (double)size().height;
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Loop and draw lines forever...
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;while (true) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Graphics
g = getGraphics();<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Randomly
select a color...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Color c
= new Color((int)(255.0 * Math.random()),<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(int)(255.0
* Math.random()),<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(int)(255.0
* Math.random()) );<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;g.setColor(c);
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;g.drawLine((int)(width
* Math.random()),<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(int)(height
* Math.random()),<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(int)(width
* Math.random()),<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(int)(height
* Math.random()) );<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// Sleep
some...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.sleep(100);
<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;}<BR>
&nbsp;&nbsp;&nbsp;}<BR>
}</TT>
</BLOCKQUOTE>
<HR>
<P>
There are a couple of interesting things to note about this applet.
It looks almost exactly like the example in the previous section.
In fact, the <TT>run()</TT> method
of Listing 8.3 is only slightly modified from that of the second
version of the LineThread class; the only changes are the removal
of the references to the Applet class and how the <TT>sleep()</TT>
method is invoked.
<P>
The thread that runs the Runnable target is constructed in the
<TT>start()</TT> method of the LineRun
class. (Keep in mind that the <TT>start()</TT>
method here is that of the Applet class and not the Thread class.)
You must check whether the thread already exists because you might
move back and forth from the line-drawing Web page to another
page. If you leave the drawing page, the Applet <TT>stop()</TT>
method kills the thread and waits for it to die. It will be restarted
if you return to the page.
<P>
An interesting thing to note about classes that implement Runnable
is that they are not &quot;dead&quot; if their <TT>run()</TT>
method has been stopped. Even if the thread is dead, the other
methods in a class using Runnable still can be invoked. For example,
add the following code to the LineRun class:
<BLOCKQUOTE>
<TT>// Toggle the running of the line-drawing
thread...<BR>
public boolean mouseDown(Event ev, int x, int y) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp; // Stop the thread if it is running...
<BR>
&nbsp;&nbsp;&nbsp;&nbsp; if (t != null) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.stop();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;try {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.join();
<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;&nbsp;&nbsp;&nbsp;t = null;
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;// If it is dead, then start a new
thread...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;else {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t = new
Thread(this);<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;t.start();
<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;return true;<BR>
};</TT>
</BLOCKQUOTE>
<P>
This code stops the thread if it is running and restarts it if
the thread is stopped. Therefore, the LineRun object is alive
regardless of whether the <TT>run()</TT>
method is active. This example points out an advantage of using
the Runnable interface over creating a subclass of Thread. When
a Thread object's <TT>run()</TT> method
is stopped, it cannot be restarted; you have to create a new Thread
to have its <TT>run()</TT> method
run again. On the other hand, an object using Runnable can have
its <TT>run()</TT> method repeatedly
started and stopped.
<P>
Another advantage of using the Runnable interface for your custom
thread is that it does carry all the baggage of the Thread class,
which supports over two dozen methods. It seems wasteful to subclass
threads so that you can override only the <TT>run()</TT>
method. On the other hand, the Thread class might be useful if
your threaded class doesn't need to be a subclass of a complex
class like Applet. In general, it's best to follow the design
versus implementation rule: If your class is designed to be a
special kind of thread, then use the Thread class; if it's designed
to be something else (like an AWT component) but needs to implement
threads, then use Runnable.
<H2><A NAME="Synchronization"><FONT SIZE=5 COLOR=#FF0000>Synchronization</FONT></A>
</H2>
<P>
As you can see from the previous examples, writing threaded classes
in Java is generally pretty easy, so you might wonder why, until
recently, relatively few languages and programs have supported
multithreading. The reason for this is that multithreading is
not without risks. In particular, a class meant to run in a concurrent
environment must be designed so that multiple threads can access
an instance of the class without causing undesired behavior. An
instance of the class must be as reliable in an environment with
multiple threads of execution as it is within a single-threaded
environment. In other words, the class must be <I>thread-safe</I>.
You will now see an example of a class that's not thread-safe.
<H3><A NAME="ATestStackClassThatIsNotThreadSaf">A TestStack Class
That Is Not Thread-Safe</A></H3>
<P>
Listing 8.4 shows the code for a class that is a stack of Integer
objects. It is a generally well-constructed class, showing good
Java programming practices, such as handling errors (like an empty
stack) by throwing exceptions. However, it is not thread-safe.
Why is this? Look at the <TT>push()</TT>
and <TT>pop()</TT> methods. They both
use the <TT>top</TT> integer variable
to indicate the current top of the stack. But what happens if
one thread is calling <TT>push()</TT>
at the same time another thread is calling <TT>pop()</TT>?
In this situation, <TT>push()</TT>
and <TT>pop()</TT> might behave in
an undesired fashion.
<HR>
<BLOCKQUOTE>
<B>Listing 8.4. A TestStack class that isn't thread-safe.<BR>
</B>
</BLOCKQUOTE>
<BLOCKQUOTE>
<TT>// Classes of stack exceptions...<BR>
class StackException extends Exception { }<BR>
class StackFullException extends StackException { }<BR>
class StackEmptyException extends StackException { }<BR>
<BR>
// This class implements a simple stack as<BR>
// an array of integers...<BR>
class TestStack {<BR>
&nbsp;&nbsp;&nbsp;Integer s[];&nbsp;&nbsp;// The stack array of
integer objects...<BR>
&nbsp;&nbsp;&nbsp;int top; // The current top of the stack. Next
item to place.<BR>
&nbsp;&nbsp;&nbsp;// Construct a stack of the specified size...
<BR>
&nbsp;&nbsp;&nbsp;public TestStack(int size) {<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;s = new Integer[size];<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;top = -1;&nbsp;&nbsp;&nbsp;//
Empty stack...<BR>
&nbsp;&nbsp;&nbsp;}<BR>
&nbsp;&nbsp;&nbsp;// Push an item onto the stack...<BR>
&nbsp;&nbsp;&nbsp;public 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;}<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;&nbsp;&nbsp;// Throw exception if stack
is empty...<BR>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;if (top &lt; 0)<BR>