线程的状态及转换
上篇简单介绍了synchronized关键字的使用，多个线程并发操作一个共享变量时，当一个线程获得对象锁，其余线程就变为阻塞状态。其实，线程除了阻塞状态，还有初始状态、就绪状态、运行状态、终止状态。
线程状态转换
上图就是线程状态转换图，有点山寨（凑合着看吧）。
状态介绍
初始状态
线程被创建，未调用start()方法。
就绪状态
调用了start()，不过还未被OS调度选中执行。
运行状态
调用了start(),且被OS调度选中执行。
阻塞状态
阻塞状态可细分三种，
等待阻塞：线程调用wait()方法，释放了锁，不能自动唤醒，需要其他线程调用notify()、notifyAll()唤醒。
同步阻塞：获取对象同步锁，同步锁被其他线程占用，转为同步阻塞，当线程再次获得锁标记，转为就绪态。
其他阻塞：运行线程执行了sleep()、join()，当sleep()结束，join()等待线程终止，转为就绪状态。
终止状态
线程执行完毕或出现异常退出了run()。
Thread方法
sleep()
public class Test6 implements Runnable{
@Override
public void run() {
for(int i = 0; i < 10; i++){
try {
//sleep()必须捕捉异常InterruptedException
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + "*****" + i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Test6 a = new Test6();
Test6 b = new Test6();
Thread thread1 = new Thread(a, "线程1");
Thread thread2 = new Thread(b, "线程2");
//setPriority是设置线程优先级，thread1为最高优先级，thread2最低优先级
thread1.setPriority(Thread.MAX_PRIORITY);
thread2.setPriority(Thread.MIN_PRIORITY);
thread1.start();
thread2.start();
}
}
执行结果：
可以看出，在sleep(long mills)会使当前线程进入阻塞状态，执行sleep()的线程在指定时间内不会执行。t1为最高优先级，t2为最低优先级，当t1阻塞的时候，t2能够执行，说明sleep(long mills)可以使低优先级线程有执行机会，同优先级就更有执行机会了。sleep(long mills)不会释放锁标记。
yield()
修改Test6的run()如下,其余不变：
@Override
public void run() {
for(int i = 0; i < 10; i++){
Thread.yield();
System.out.println(Thread.currentThread().getName() + "*****" + i);
}
}
执行结果：
当t1的优先级为最高级，t2的优先级为最低级，可以看出，t2只能等t1执行完毕后，才有执行的机会，也就是说yield()只能让同等优先级的线程有执行的机会。yield()方法没有任何参数。
join()
/**
* Created by bxw on 2017/9/19.
*/
public class Test6 implements Runnable{
@Override
public void run() {
for(int i = 0; i < 10; i++){
System.out.println(Thread.currentThread().getName() + "*****" + i);
}
}
public static void main(String[] args) throws InterruptedException {
Test6 a = new Test6();
Test6 b = new Test6();
Thread thread1 = new Thread(a, "线程1");
Thread thread2 = new Thread(b, "线程2");
thread1.start();
thread2.start();
}
}
执行结果：
这个结果是意料之中，比较和谐，t1和t2交替执行。在main()方法中加一句thread.join()试试
public static void main(String[] args) throws InterruptedException {
Test6 a = new Test6();
Test6 b = new Test6();
Thread thread1 = new Thread(a, "线程1");
Thread thread2 = new Thread(b, "线程2");
thread1.start();
thread2.start();
//新加的join可以放在最后，也可以放在thread1.start()之前
thread1.join();
}
执行结果：
结果显示，t1执行完毕后，t2才有机会执行。join()方法简通俗点讲就是"插一腿"，可以临时加入一个线程，等这个线程执行完毕，另一个线程继续执行。拿这个例子来说，当主线程碰到t1.join()，t1要加入运行中，获得cpu执行权，cpu执行权就从主线程转到t1手中，等t1执行完后，主线程再恢复到运行中。
Object方法
wait()
在其他线程调用此对象的notify()或notifyAll()方法前，导致当前线程等待。当前线程必须拥有锁标记，执行wait()后，释放锁标记并等待，知道其他线程通过notify()或notifyAll()方法通知在此所标记上的等待线程。
notify()
唤醒在此锁标记上等待的单个线程，如果锁标记上有多个线程，会随机唤醒一个，被唤醒的等待线程并不会立即执行，而是要等到目前拥有锁标记的线程释放锁后，以常规方式与在该锁标记上同步的其他线程重新进行锁标记竞争。
notifyAll()
唤醒在此锁标记上等待的所有线程。
public class Test7 {
//定义一个锁标记
private static final String lock = new String("锁");
private static class Thread1 implements Runnable{
@Override
public void run() {
synchronized (lock){
System.out.println("thread1开始执行了");
System.out.println("thread1要wait了");
try {
//wait()会释放锁标记
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("thread1继续执行");
System.out.println("thread1执行完毕");
}
}
}
private static class Thread2 implements Runnable{
@Override
public void run() {
//必须和Thread1用同一个锁标记，不然两个对象两个锁就失去意义了
synchronized (lock){
System.out.println("thread2开始执行了");
System.out.println("thread2要notify了");
lock.notify();
System.out.println("thread2继续执行");
System.out.println("thread2执行完毕");
}
}
}
public static void main(String[] args) {
Thread1 a = new Thread1();
Thread2 b = new Thread2();
Thread thread1 = new Thread(a, "线程1");
Thread thread2 = new Thread(b, "线程2");
thread1.start();
thread2.start();
}
}
执行结果：
可以看出，thread2线程调用notify()方法后不会释放锁标记，必须要等到同步代码块执行完毕后才释放。所以，thread2的开始和结束是成对挨着出现的。
总结
本篇主要介绍了线程的五个状态以及状态之间转换所用到的方法。sleep(long mills)、yield()、join()都是Thread的方法，wait()、notify()、notifyAll()都是Object的方法。sleep和wait的区别：①首先是方法的归属不同，sleep是Thread，wait是Object；②sleep()可以在任何地方使用，wait只能在同步块中使用；③sleep不会释放锁标记，到时间了就从阻塞态转为就绪态，wait需要notify()、notifyAll()唤醒，且重新获得锁标记后才会转为就绪态。
略陈固陋，如有不当之处，欢迎各位看官批评指正！
