ex2.java

讲述各种各样的java初始编程 了解编程

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package chenchao6;



/**
 *
 * @author williechen
 */
public class Ex2 {

    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++) {
                    ThreadDemo.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++) {
             ThreadDemo.compute();
        }

    }
}

class ThreadDemo extends Thread {

    /**
     * This method overrides the run() method of Thread.  It provides
     * the body for this thread.
     **/
    @Override
    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.
     **/
    // 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();    
    }
}