|
|
A thread can be loosely defined as a separate stream of execution that takes
place simultaneously with and independently of everything else that might be happening. A
thread is like a classic program that starts at point A and executes until it
reaches point B. It does not have an event loop. A thread runs independently
of anything else happening in the computer. Without threads an entire program can be held
up by one CPU intensive task or one infinite loop, intentional or otherwise. With threads
the other tasks that don't get stuck in the loop can continue processing without waiting
for the stuck task to finish.
It turns out that implementing threading is harder than implementing multitasking in an operating system. The reason it's relatively easy to implement multitasking is that individual programs are isolated from each other. Individual threads, however, are not. To return to the printing example, suppose that while the printing is happening in one thread, the user deletes a large chunk of text in another thread. What's printed? The document as it was before the deletion? The document as it was after the deletion? The document with some but not all of the deleted text? Or does the whole system go down in flames? Most often in a non-threaded or poorly threaded system it's the latter.
Threaded environments like Java allow a thread to put locks on shared resources so that while one thread is using data no other thread can touch that data. This is done with synchronization. Synchronization should be used sparingly since the purpose of threading is defeated if the entire system gets stopped waiting for a lock to be released. The proper choice of objects and methods to synchronize is one of the more difficult things to learn about threaded programming.
Java has two ways a program can implement threading. One is to create a subclass of java.lang.Thread.
However sometimes you'll want to thread an object that's already a subclass of another
class. Then you use the java.lang.Runnable interface.
The Thread class has three primary methods that are used to control a
thread:
public native synchronized void start()
public void run()
public final void stop()
The start() method prepares a thread to be run; the run()
method actually performs the work of the thread; and the stop() method halts
the thread. The thread dies when the the run() method terminates
or when the thread's stop() method is invoked.
You never call run() explicitly. It is called automatically by the runtime
as necessary once you've called start(). There are also methods to supend and
resume threads, to put threads to sleep and wake them up, to yield control to other
threads, and many more. I'll discuss these later.
The Runnable interface allows you to add threading to a class which, for
one reason or another, cannot conveniently extend Thread. It declares a single method, run():
public abstract void run()By passing an object which implements Runnable to a Thread()
constructor, you can substitute the Runnable's run() method for the Thread's
own run() method. (More properly the Thread object's run()
method simply calls the Runnable's run() method.)
example of one thread ---one ball bouncing
multipule threads --------two balls bounding --independent of each other
ASSIGNMENT--add two more balls to the second example and add a stop and start button for the first ball only.