Java线程详解：wait、notify、notifyAll、join

线程的概念

线程是进程的子任务，一个进程可以创建多个线程，线程不拥有系统资源，但是线程可以共享进程的资源，而线程自己也有一块独立的小块空间：包括堆栈，程序计数器和局部变量。
线程是CPU调度和分派的基本单位。在同一时刻cpu只能执行一段代码，或者说叫一段顺序执行流，也就是线程。cpu在不同的线程之间来回切换，因为cpu的运行速度非常高，看起来就像这些线程一起执行一样，这就是并发。

线程状态

从不同的角度，会有不同的结果。
说到线程的状态，网上的说法众说纷纭，有说5种的，有说6种的，还有说7种的。具体怎么回事呢，得看是从什么角度来看。、
从操作系统来看： 线程可以分为5个状态

1. 新建状态(NEW)
   线程的初始状态，还没有调用线程的start()方法
2. 就绪状态(READY)
   线程启动之后，就进入就绪状态，等待cpu分配时间片执行。处于就绪状态的线程，只是说线程做好了cpu随时调用执行的准备
3. 执行状态（RUNNING)
   cpu开始调度执行处于就绪状态的线程时，线程就是执行状态了。要想线程进入执行状态，它必须先是就绪状态
4. 阻塞状态（BLOCKED）
   当处于运行状态的线程，由于某些原因暂时放弃cpu的使用权，则处于阻塞状态。直到其进入就绪状态，cpu才可以重新调度执行它。
5. 终止状态（TERMINATED）
   线程执行完成或异常退出，线程终止。

而Java中，线程则分了6种状态。
新建和终止状态跟上面一样，就绪和执行状态，Java线程将这两种合并为一种：RUNNABLE：运行状态，表示线程已经在虚拟机中执行了。而阻塞状态，Java将之细分了3个状态: BLOCKED,WAITING,TIMEED_WAITING。
在Thread.State枚举中列举了这6种状态：

1. 新建状态（NEW)
   Thread 创建之后的初始状态，还未调用start()方法，只是内存中的一个对象，操作系统并没有创建线程。
2. 运行状态（RUNNABLE）
   线程已经在java虚拟机中执行，可能cpu调度已经正式开始运行，也有可能等待cpu调度。
3. 阻塞状态（BLOCKED）
   在Java中，BLOCKED 状态跟内置锁synchronized（也叫监视器锁）关联，线程在等待获取其它线程持有的监视器锁进入同步代码块时，线程处于BLOCK状态。或者在线程调用wait方法之后等待重新进入同步代码块，也处于BLOCK状态。BLOCK只跟监视器锁有关，如果不需要进入同步代码块，而是因为其它的原因线程需要等待，不属于BLOCK.
4. 等待状态（WAITING ）
   一个线程由于调用了以下方法之一： Object.wait(),Thread.join(),LockSupport.park()而处于等待状态。
   处于WAITING状态的线程在等待其它线程执行特定的行为。例如：
   一个线程A调用了某个对象上的wait()方法，需要等待其它线程去执行对象上的notify()或者notifyAll()方法,线程A才会结束等待。
5. 限时等待（TIMED_WAITING）
   一个线程由于调用了以下方法之一： Thread.sleep(long),Object.wait(long),Thread.join(long),LockSupport.parkNanos(long),LockSupport.parkUtil(long) 而等待。从这个命名上也说明是限时等待，不会无限等待下去，特定时间之后即使它等待的事件没有发生，也会退出等待状态继续执行。
   终止状态（TERMINATED)
   线程已经终止，包括正常执行完成或者异常退出。

线程通信： wait, notify, notifyAll, join

上面在RUNNABLE到WAITING,TIMED_WAITING状态的转换过程中，提到了wait，notify等方法。

wait

该方法是Object的一个实例方法，

/   ** @throws  IllegalMonitorStateException  if the current thread is not
     *               the owner of the object's monitor.
     * @throws  InterruptedException if any thread interrupted the
     *             current thread before or while the current thread
     *             was waiting for a notification.  The <i>interrupted
     *             status</i> of the current thread is cleared when
     *             this exception is thrown.
     * @see        java.lang.Object#notify()
     * @see        java.lang.Object#notifyAll()
     * /
 public final void wait() throws InterruptedException {
        wait(0);
    }

这也表明任何对象都可以调用wait方法：此时会释放对象的监视器锁，（监视器锁是内置锁的另一种称呼，两者是一样的），并且当前线程（标记为线程T）会保持休眠
直到发生一下四种情况之一：

1. 其它线程调用该对象上的notify方法，并且当前线程正好被选中唤醒
2. 其它线程调用该对象上notifyAll方法
3. 其它线程中断了当前线程，当前线程的中断标志也会被清除
4. 调用wait时传入了一个正数的等待时间，等待的时间过去

以上四种情况发生之后,线程T结束休眠，重新进入线程调度：它会按正常的方式与其他线程竞争锁。也就是说，休眠结束后，线程的同步状态跟调用wait前完全一样。
第3种情况中，wait方法会抛出InterruptedException异常，并且将线程的中断标志清除
第4种情况中，等待的时间过后如果线程在竞争中没有获得内置锁，后续代码也是无法执行的，超时时间达到仅仅是把线程从休眠状态中移出

调用wait方法的线程必须拥有对象的监视器锁，怎么拥有呢，有3种方式：
5. 调用对象的synchronized同步方法
6. 执行锁定在这个对象上的同步代码块
7. 对于Class对象，执行该类上的静态同步方法（static synchronized methodName）

这也跟Java内置锁 synchronized里的“获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法”说法一致。
如果线程没有获得这个对象的监视器锁呢，wait方法会抛出 IllegalMonitorStateException异常。

虚假唤醒

我们调用wait时，经常是需要判断某些条件的，例如当某某资源找不到时，调用wait方法。通常会这么写

synchronized(obj){
do