ThreadDemopublic class ThreadDemo extends 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 |
| Fields Summary |
|---|
| static ThreadLocal | numcalls |
| Methods Summary |
|---|
| static synchronized void | compute()This is the dummy method our threads all call
// 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();
| | public static void | main(java.lang.String[] args)This main method creates and starts two threads in addition to the
initial thread that the interpreter creates to invoke the main() method.
// 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()).
| | public void | run()This method overrides the run() method of Thread. It provides
the body for this thread. for(int i = 0; i < 5; i++) compute();
|
|
