Java线程的join()方法

join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在主线程中调用了线程A的join()方法（A.join()），则直到线程A执行完毕后，才会继续执行线程主线程。

t.join(); 等待线程 t 执行完毕，再执行调用t线程方法的线程。(大概就是这个意思)
t.join(1000); 等待 t 线程，等待时间是1000毫秒。

下面是join方法的源码

 public final synchronized void join(long millis) 
    throws InterruptedException {
    long base = System.currentTimeMillis();
    long now = 0;

    if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
    }

    if (millis == 0) {
        while (isAlive()) {
        wait(0);
        }
    } else {
        while (isAlive()) {
        long delay = millis - now;
        if (delay <= 0) {
            break;
        }
        wait(delay);
        now = System.currentTimeMillis() - base;
        }
    }
    }

从代码上看，如果线程生成了，但还未被起动，调用它的 join() 方法是没有作用的，将直接继续向下执行。join方法实现是通过wait（Object 类的方法）。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁。

关于多线程的同步与锁，可以参考多线程的同步与锁。

下面是一道面试题：

package Test03;
public class Demo01 {
    public static void main(String[] args) throws InterruptedException{
        Thread t=new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("Begin sleeping!");
                    Thread.sleep(2000);//1
                    System.out.println("End sleeping");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("run方法结束！");
            }
        });
        t.start();
        t.join(1000);//2
        System.out.println("joinFinish!");
        System.out.println("主方法结束！");
    }
}

结果为：
Begin sleeping!
joinFinish!
主方法结束！
End sleeping
run方法结束

这里t线程睡了2000毫秒，主线程只等待1000毫秒，所以结果如上。
假如2处改为3000,则结果为：
Begin sleeping!
End sleeping
run方法结束！
joinFinish!
主方法结束！