Java线程Step By Step(Step 2)

（See http://www.suneca.com/article.asp?id=54）

四、Join方法的使用    
Thread API 包含了等待另一个线程完成的方法：join() 方法。当调用 Thread.join() 时，调用线程将阻塞，直到被join方法加入的目标线程完成为止。 可以于解起来抽象一睦，现在我们来举一个例子说明问题。

 程序代码

package zizz;

/**
* 使用继承方式的线程实现.
* 
* @author <a href="http://www.suneca.com">zizz</a>
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {
    
    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + i);
        }
    }
    
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread();
        //线程进入运行态
        t1.start();
        //主线程输出
        System.out.println("主线程输出：http://www.suneca.com");
    }
}

输出结果为：


从结果我们可以看到，对于我们运行MyThread这个程序，在主线程当中创建一个新的子线程，新的子线程启动后，主线程输出博客地址。因为当前主线程处于运行态，而子线程是处于可运行态，所以输出的结果为先输出网址，再输出了线程输出的数据。但也有可能会出现这种情况，子线程进入可运行态之后，马上进入运行态，那此时的是输出子线程的数据，再输出主线程的数据，它们的执行完全是由线程调度器进行调度。我们再将程序做如下的修改：

 程序代码

package zizz;

/**
* 使用继承方式的线程实现.
* 
* @author <a href="http://www.suneca.com">zizz</a>
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {
    
    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=100;i++){
            System.out.println("子线程输出：" + i);
        }
    }
    
    /**
     * 应用程序入口.
     * 
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread();
        //线程进入运行态
        t1.start();
        //主线程输出
        for(int i=0;i<100;i++){
            System.out.println("主线程输出：http://www.suneca.com");
        }
    }
}

此时的输出结果为：



主线程跟子线程在线程调度器的调度下，相互抢夺CPU资源，交叉运行着！

那么，如果我希望程序启用子线程，必须等待着子线程执行完毕之后，主线程才能继续执行下去，那该怎么办？那此时，我们就必须使用到join这个方法啦！当使用Thread.join()时，调用线程将阻塞。因为子线程是由主线程进行调用的，所以当子线程调用到join这个函数时，主线程将阻塞，必须等待子线程执行完毕之后，才能继续执行。使用join的程序：

 程序代码

package zizz;

/**
* 使用继承方式的线程实现.
* 
* @author <a href="http://www.suneca.com">zizz</a>
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {
    
    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + i);
        }
    }
    
    /**
     * 应用程序入口.
     * 
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread();
        //线程进入运行态
        t1.start();
        try {
            //线程的调用者，即主线程阻塞！
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程输出
        for(int i=0;i<10;i++){
            System.out.println("主线程输出：http://www.suneca.com");
        }
    }
}

输出结果为：



从结果当中，我们可以看出，当子线程调用到join的时候，主线程将阻塞，子线程执行完毕之后，主线程才能继续执行。对于join()方法，还有两个重载方法，比如joing(long millis)，那就是让主程序阻塞多长时间后才能恢复到可运行状态。

如果主程序调用了两个子线程，那这两个子线程是如何工作的呢？

 程序代码

package zizz;

/**
* 使用继承方式的线程实现.
* 
* @author <a href="http://www.suneca.com">zizz</a>
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {
    
    public MyThread(String name){
        super(name);
    }
    
    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=100;i++){
            System.out.println("子线程输出：" + this.getName() + " - " + i);
        }
    }
    
    /**
     * 应用程序入口.
     * 
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
        //线程进入运行态
        t1.start();
        t2.start();
        try {
            //线程的调用者，即主线程阻塞！
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //主线程输出
        for(int i=0;i<10;i++){
            System.out.println("主线程输出：http://www.suneca.com");
        }
    }
}

输出结果：



从图的输出结果我们可以看出：对于在线程t1跟线程t2当中都调用了线程的join()方法，那么，调用t1、t2的主线程将阻塞，等到t1、t2都执行完毕之后，再执行主线程。对于子线程t1跟t2，它们的一个先后顺序，如何进行调度，完全是由线程调度器进行管理！

五、多线程
从前面的例子我们已经可以看出，对于有两个以上的线程同时启动，那这些线程的执行的先后顺序我们是没有办法预知的，因为对于它们的调用完全是由线程调度器进行调用！当子线程t1跟t2同时处于运行状态，那谁先执行谁慢执行，由线程调度器决定。那我们程序能否进行控制呢？答案是可以的，我们可以通过设计优先级别来进行控制。每一个线程，默认的优先级别为5，值越高，表示优先级别越高（最高为10），值越低（最低为1），表示优先级别越低！当线先级别相等的时候，那就只有排队等待着线程调度器的调用。

 程序代码

package zizz;

/**
* 使用继承方式的线程实现.
* 
* @author <a href="http://www.suneca.com">zizz</a>
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {
    
    public MyThread(String name){
        super(name);
    }
    
    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + this.getName() + " - " + i);
        }
    }
    
    /**
     * 应用程序入口.
     * 
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
        
        //线程进入运行态
        t1.start();
        t2.start();
        //主线程输出  
        System.out.println("主线程输出：http://www.suneca.com");
        
    }
}

t1比t2先启动，进入可运行态，排队等候线程的调度。执行结果：



如果设置了线程的优先级，如：

 程序代码

package zizz;

/**
* 使用继承方式的线程实现.
* 
* @author <a href="http://www.suneca.com">zizz</a>
*
* @Create-Time:2008 下午10:25:33
*/
public class MyThread extends Thread {
    
    public MyThread(String name){
        super(name);
    }
    
    public void run() {
        //循环输出1 到 100
        for(int i=1;i<=10;i++){
            System.out.println("子线程输出：" + this.getName() + " - " + i);
        }
    }
    
    /**
     * 应用程序入口.
     * 
     * @param args
     */
    public static void main(String[] args){
        //创建一个线程实例
        MyThread t1 = new MyThread("t1");
        MyThread t2 = new MyThread("t2");
        
        //设置t1的的优先级别为最低
        t1.setPriority(Thread.MIN_PRIORITY);
        //设置t2的优先级别为最高
        t2.setPriority(Thread.MAX_PRIORITY);        
        
        //线程进入运行态
        t1.start();
        t2.start();
        //主线程输出  
        System.out.println("主线程输出：http://www.suneca.com");
        
    }
}

执行结果：

从结果当中我们可以看到，最早的时候是由主线程执行，主线程占用着CPU资源，接着，线程t1启动，线程t1进入排队，等候着线程调度器的调度；再接着，线程t2启动，线程t2也进入排队。
我们从结果当中更可以发现一点，对于高于5的线程优先级别，它更容易从当中正在执行的线程(主线程)当中抢夺CPU资源。

多线程的另外一种情况就是，多个线程共享同一个线程实例。

 程序代码

package zizz;

/**
* 使用实现Runnable接口的线程.
* 
* @author <a href='http://www.suneca.com'>ZIZZ</a>
*
* @Create-Time:2008 下午10:48:31
*/
public class MyRunnable implements Runnable{

    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName() + " : " + i);
        }
    }
    
    public static void main(String[] args){
        //构造一个Runnable的实例
        MyRunnable runnable = new MyRunnable();
        //创建新的线程
        Thread t1 = new Thread(runnable,"T1");
        Thread t2 = new Thread(runnable,"T2");
        
        //线程启动.
        t1.start();
        t2.start();
    }

}

执行结果片断：



当多线程共享同一个线程实例的时候，我们需要考虑一下线程的同步问题。