多线程-join()方法

在很多情况下，主进程创建并启动子线程，如果子线程中要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。这时，如果主线程想等待子线程执行完成之后再结束，比如子线程处理一个数据，主线程要取得这个数据中的值，就要用到join()方法了。方法join()的作用是等待线程对象销毁。

package org.github.lujiango;

public class Test01 {

    static class MyThread  extends Thread {
        @Override
        public void run() {
            try {
                int sec = ( int ) (Math.random() *  10000 );
                System.out.println(sec);
                Thread.sleep(sec);
            }  catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        try {
            MyThread t =  new MyThread();
            t.start();
            t.join();
            System.out.println( "我想当t对象执行完毕后我再执行..." );
        }  catch (Exception e) {
            e.printStackTrace();
        }
    }

}

方法join的作用是使所属的线程对象x正常执行run()方法中的任务，而使当前线程z进行无限期的阻塞，等待线程x销毁后再继续执行线程z后面的代码。 
方法join具有使线程排队运行的作用，有些类似同步的运行效果。join与synchronized的区别是：join在内部使用wait()方法进行等待，而sychronized关键字使用的是“对象监视器”原理作为同步。 
join方法的签名 
join的功能内部是使用wait(long)方法来实现的，所有join方法具有释放锁的特点：

public final void join()  throws InterruptedException{
               join( 0 ); 
}

@param millis 等待时间，单位：毫秒（如果超时，则因为另一个线程join而导致阻塞的线程继续执行）

public final synchronized void join( long millis)  throws InterruptedException {}

join与异常

在join过程中，如果当前线程对象被中断，则当前线程出现异常。　　

package org.github.lujiango;

public class Test02 {

    static class ThreadA  extends Thread {
        @Override
        public void run() {
            for ( int i =  0 ; i < Integer.MAX_VALUE; i++) {
                String newString =  new String();
                Math.random();
            }
        }
    }

    static class ThreadB  extends Thread {
        @Override
        public void run() {
            try {
                ThreadA a =  new ThreadA();
                a.start();
                a.join();
                System.out.println( "Thread B run end..." );
            }  catch (Exception e) {
                System.out.println( "Thread B catch" );
                e.printStackTrace();

            }
        }
    }

    static class ThreadC  extends Thread {
        private ThreadB threadB;

        public ThreadC(ThreadB threadB) {
            this .threadB = threadB;
        }

        @Override
        public void run() {
            threadB.interrupt();
        }
    }

    public static void main(String[] args) {
        try {
            ThreadB b =  new ThreadB();
            b.start();
            Thread.sleep( 500 );
            ThreadC c =  new ThreadC(b);
            c.start();
        }  catch (Exception e) {
            e.printStackTrace();
        }
    }
}

join与interrupt方法如果遇到，就会出现异常，但今次按钮还是呈“红色”，原因是线程a还在继续运行，a未出现异常，是正常执行的状态。