4.1 Thread Basics

Example 4-1 is a simple program that demonstrates how to define, manipulate, and run threads. The bulk of the program is the main( ) method; it is run by the initial thread created by the Java interpreter. This main( ) method defines two additional threads, sets their priorities, and starts them running. The two threads are defined using two different techniques: the first is defined by subclassing the Thread class, while the second implements the Runnable interface and passes a Runnable object to the Thread( ) constructor. The example also demonstrates how you might use the important sleep( ), yield( ), and join( ) methods. Finally, Example 4-1 demonstrates the java.lang.ThreadLocal class, which has been added as of Java 1.2.

Example 4-1. ThreadDemo.java

package je3.thread; /**  * This class demonstrates the use of threads.  The main( ) method is the   * initial method invoked by the interpreter.  It defines and starts two  * more threads and the three threads run at the same time.  Note that this  * class extends Thread and overrides its run( ) method.  That method provides  * the body of one of the threads started by the main( ) method  **/ public class ThreadDemo extends Thread {     /**      * This method overrides the run( ) method of Thread.  It provides      * the body for this thread.      **/     public void run( ) { for(int i = 0; i < 5; i++) compute( ); }          /**       * This main method creates and starts two threads in addition to the       * initial thread that the interpreter creates to invoke the main( ) method.      **/     public static void main(String[  ] args) {         // Create the first thread: an instance of this class.  Its body is         // the run( ) method above         ThreadDemo thread1 = new ThreadDemo( );                  // Create the second thread by passing a Runnable object to the          // Thread( ) construtor.  The body of this thread is the run( ) method         // of the anonymous Runnable object below.         Thread thread2 = new Thread(new Runnable( ) {                 public void run( ) { for(int i = 0; i < 5; i++) compute( ); }             });                  // Set the priorities of these two threads, if any are specified         if (args.length >= 1) thread1.setPriority(Integer.parseInt(args[0]));         if (args.length >= 2) thread2.setPriority(Integer.parseInt(args[1]));                  // Start the two threads running         thread1.start( );         thread2.start( );         // This main( ) method is run by the initial thread created by the         // Java interpreter.  Now that thread does some stuff, too.         for(int i = 0; i < 5; i++) compute( );         // We could wait for the threads to stop running with these lines         // But they aren't necessary here, so we don't bother.         // try {         //     thread1.join( );         //     thread2.join( );         // } catch (InterruptedException e) {  }         // The Java VM exits only when the main( ) method returns, and when all         // threads stop running (except for daemon threads--see setDaemon( )).     }     // ThreadLocal objects respresent a value accessed with get( ) and set( ).     // But they maintain a different value for each thread.  This object keeps     // track of how many times each thread has called compute( ).     static ThreadLocal numcalls = new ThreadLocal( );     /** This is the dummy method our threads all call */     static synchronized void compute( ) {         // Figure out how many times we've been called by the current thread         Integer n = (Integer) numcalls.get( );         if (n == null) n = new Integer(1);         else n = new Integer(n.intValue( ) + 1);           numcalls.set(n);         // Display the name of the thread, and the number of times called         System.out.println(Thread.currentThread( ).getName( ) + ": " + n);         // Do a long computation, simulating a "compute-bound" thread         for(int i = 0, j=0; i < 1000000; i++) j += i;         // Alternatively, we can simulate a thread subject to network or I/O         // delays by causing it to sleep for a random amount of time:         try {             // Stop running for a random number of milliseconds             Thread.sleep((int)(Math.random( )*100+1));           }         catch (InterruptedException e) {  }         // Each thread politely offers the other threads a chance to run.         // This is important so that a compute-bound thread does not "starve"         // other threads of equal priority.         Thread.yield( );     } }