生命周期
Java线程有新建（New）、就绪（Runable）、执行（Running）、阻塞（Blocked）、死亡（Dead）五种状态。
- 新建状态
线程创建完成时，即new Thread(…)还没调用start前的状态。 - 就绪
调用线程的start()方法后，进入就绪状态，等待CPU资源。就绪状态的线程由Java运行时系统的线程调度成都（thread scheduler）来调度。 - 执行
就绪状态的线程获得CPU执行权后，开始执行run()方法。 - 阻塞
线程没有执行完，由于某种原因（IO操作等）让出CPU执行权，自身进入阻塞状态。 - 死亡
线程执行完成，或者执行过程中出现异常，线程就会进入死亡状态。
状态控制
wait
wait/notify/notifyAll是Object类的方法。可以实现该Object所在的线程Running -> Blocked的状态变化。
方法 | 作用 |
void wait() | 将该对象所在的所有线程挂起（及让其进入阻塞Blocked状态），知道notify()或者notifyAll()方法来唤醒 |
void wait(long timeout) | 将对象所在的所有线程挂起，如果没有notify/notifyAll唤醒，则在timeout毫秒后自动唤醒。wait()与wait(0)等效 |
void wait(long timeout, int nanos) | 挂起线程，若未被唤醒则在timeout毫秒+nanos纳秒后唤醒。本意是更精确地控制唤醒时间，但是从源码（1.8）看，纳秒只实现了四舍五入。 |
需要注意：
- 直接调用wait方法会抛出java.lang.IllegalMonitorStateException异常。
因为wait方法是一个本地native方法，其实现是通过获取对象监视器的所有权，而对象所有权只有一个线程可以获取，获取了对象监视器等于给对象加锁，从而实现线程的阻塞。而Java中只能通过Synchronized关键字获取对象监视器所有权。翻译成JVM指令就是：
montiorenter 进入并获取对象监视器
monitorexit 释放并退出对象监视器
所以，wait方法必须在同步范围内使用。 - 调用wait()方法后，线程会释放对该对象monitor的所有权（锁）。
- 阻塞线程被唤醒后，要竞争到monitor所有权才能继续执行。
notify/notifyAll
notify/notifyAll是Object类的方法。可以实现该Object所在的线程Blocked -> Runnable的状态变化。
方法 | 作用 |
void notify() | 唤醒该对象阻塞状态的线程，即在等待monitor的线程 |
void notifyAll() | 与notify()方法的区别是，notify()只能唤醒一个等待monitor的线程，而notifyAll()可以唤醒所有等下monitor的锁。 |
sleep
sleep()是Thread类的方法。可以实现当前线程Running->Blocked的状态变化。
Thread.sleep(long timeout)的作用是让当前线程暂停timeout毫秒，与wait()的区别是，wait方法依赖于同步，需要释放对象监视器才能阻塞线程；而sleep只是暂时释放CPU执行权，并不释放锁。
yield
yield()是Thread类的方法。可以实现当前线程Running->Runnable的状态变化。
yield()目的是暂停当前线程，让出资源给优先级更高的线程。
不能指定暂停时间，也不能保证线程能马上停止。
public class TestYield implements Runnable {
@Override
public void run() {
for (int i=0; i<10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
Thread.yield();
}
}
public static void main(String[] args) {
TestYield runnable = new TestYield();
new Thread(runnable, "A").start();
new Thread(runnable, "B").start();
}
}A:0
B:0
A:1
B:1
A:2
B:2
A:3
B:3
A:4
B:4
A:5
B:5
A:6
B:6
A:7
B:7
A:8
B:8
A:9
B:9可以看出yield()可以实现线程交替执行，不过这种交替得不到保证，源码也做出声明。
/**
* A hint to the scheduler that the current thread is willing to yield
* its current use of a processor. The scheduler is free to ignore this
* hint.
*
* <p> Yield is a heuristic attempt to improve relative progression
* between threads that would otherwise over-utilise a CPU. Its use
* should be combined with detailed profiling and benchmarking to
* ensure that it actually has the desired effect.
*
* <p> It is rarely appropriate to use this method. It may be useful
* for debugging or testing purposes, where it may help to reproduce
* bugs due to race conditions. It may also be useful when designing
* concurrency control constructs such as the ones in the
* {@link java.util.concurrent.locks} package.
*/这段话主要说明了三个问题：
- 调度器可能会忽略该方法。
- 使用的时候要仔细分析和测试，确保能达到预期的效果。
- 很少有场景要用到该方法，主要使用的地方是调试和测试。
join
join()是Thread类的方法。可以实现当前线程Running->Blocked->Runnable的状态变化。
Thread.join()的作用是让父线程等待子线程执行完成后再执行，换句话说就是将异步执行的线程合并为同步线程。
JDK1.8源码：
public final void join() throws InterruptedException {
join(0);
}
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;
}
}
}
public final synchronized void join(long millis, int nanos)
throws InterruptedException {
if (millis < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos >= 500000 || (nanos != 0 && millis == 0)) {
millis++;
}
join(millis);
}可以看出，join方法是用wait()阻塞当前线程（主线程），如果子线程还在执行，继续阻塞主线程。
总结
为什么wait/notify/notifyAll方法位于Object类，而sleep/join/yield方法在Thread类？
因为wait的实现依赖于对象监视器，而对象监视器是属于Object的。
