多线程-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为出现异常，是正常执行的状态。

转载于:https://www.cnblogs.com/lujiango/p/7580789.html