多线程(3) — join关键字

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
...
======