join ，用于等待其他线程完毕，即等待join的线程方法完成后再运行，否则处于阻塞状态。当在多线程中的某个线程使用join()那么之前的线程会等待join完成后再运行。在Join的API中描述为：“等待该线程完成”。
eg：在A、B两个线程中，A调用B.join()，那么此时A会阻塞直到B执行完了A再接着执行。
看例子：
public class Join {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 30; i++) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 30; i++) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
});
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 30; i++) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
});
t1.start();
t1.join(); // 线程1调用join
t2.start();
t3.start();
}
}
======console======
Thread-0
Thread-0
...
Thread-0
Thread-0
Thread-0
Thread-2
Thread-1
Thread-2
Thread-1
Thread-2
Thread-1
...
发现线程1加了join()后第其他线程(包括主线程)就阻塞了，也就是说，在开启线程后调用join()就会让其他线程等待当前线程，当join线程完成了其他线程才开始运行。这也体现了join API中的“等待该线程完成”这句话。
但是同样的代码，如果将t2设置成join的，(当然在线程调用start之后再调用join)那么按照之前的理解应该是t2运行，t1，t3及主线程应该阻塞等待t2运行完再运行：
结果如下：
......
t1.start();
t2.start();
t2.join(); // 线程2调用join
t3.start();
......
======console======
...
～～～ 线程1准备启动～～～
～～～ 线程2准备启动～～～
～～～ 线程2准备join～～～
Thread-1
Thread-0
Thread-0
Thread-1
Thread-0
Thread-1
Thread-0
Thread-1
Thread-0
...
～～～ 线程3准备启动～～～
Thread-2
Thread-2
Thread-2
Thread-2
Thread-2
Thread-2
Thread-2
从结果中可以看出t1启动了再启动t2，然后t2在join之后与之前的t1线程一起运行，而后面的t3并没有运行，直到t1与t2相互打印到t2结束了，t3才开始与未完成的t1一起再执行。
这出现了个问题，为什么t1，t2 start之后，调用t2.join(), t1依旧还在运行？
先来看看join的底层源码：
// 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()是一个final的synchronized方法，因为join方法是一个 synchronized 的同步方法。
举个例子，join是在main方法里被调用了。然后main方法就持有了 join方法的这个锁。然后join方法里面调用了 wait方法。这个过程的目的是让持有这个同步锁的线程进入等待。
那么谁持有了这个同步锁呢？
答案就是main方法，因为main方法调用了join方法。main方法就持有 synchronized 标记的这个锁，谁持有这个锁谁就等待。wait()方法只会让持有锁的线程进入等待，而启动线程的 start() 并没有持有锁，所以strat方法还是会执行，而join方法中的wait方法 使main 方法等待了。所以main方法就没有获取到CPU资源。然后join方法执行完之后，JVM底层执行了notify的操作。notify_all 之后 join方法结束，自然 main方法又获取到cpu资源了，然后thread2又可以取得cpu资源，然后又是这个过程。
所以，join是指在目前没有获得到锁的运行的线程中和join线程一起执行直到join线程终止，后面的线程再开始执行与其他线程执行。
（打印多次有种预感，join后线程的优先级好像高了些，上例中打印多次发现t1与t2一起时明显t2打印的多优先级高，所以join是否对优先级有影响后面再好好研究。。）
另外，Join是控制多线程的顺序的一种简单的实现方法：
比如上面的改成：
...
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
...
======console======
Thread-0
Thread-0
Thread-0
...
Thread-1
Thread-1
Thread-1
...
Thread-2
Thread-2
...
======
