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( ); } }
Get Java Examples in a Nutshell, 3rd Edition now with the O’Reilly learning platform.
O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.