Java 多线程 线程的五种状态，线程 Sleep, Wait, notify, notifyAll

一、先来看看Thread类里面都有哪几种状态，在Thread.class中可以找到这个枚举，它定义了线程的相关状态:

 public enum State {
     NEW,
     RUNNABLE,
     BLOCKED,
     WAITING,
     TIMED_WAITING,
     TERMINATED;
 }

具体解释请见源码，下面简单解释下Thread的五种状态什么时候出现：

1. NEW 新建状态，线程创建且没有执行start方法时的状态
2. RUNNABLE 可运行状态，线程已经启动，但是等待相应的资源（比如IO或者时间片切换）才能开始执行
3. BLOCKED 阻塞状态，当遇到synchronized或者lock且没有取得相应的锁，就会进入这个状态
4. WAITING 等待状态，当调用Object.wait或者Thread.join()且没有设置时间，在或者LockSupport.park时，都会进入等待状态。
5. TIMED_WAITING 计时等待，当调用Thread.sleep()或者Object.wait(xx)或者Thread.join(xx)或者LockSupport.parkNanos或者LockSupport.partUntil时，进入该状态
6. TERMINATED 终止状态，线程中断或者运行结束的状态

二、Sleep 与 Wait 的区别

由于wait方法是在Object上的，而sleep方法是在Thread上，当调用Thread.sleep时，并不能改变对象的状态，因此也不会释放锁。请看下面代码结果：

 package springBootExample.example.simpleApplication;

 public class TestThread {

     public static void main(String[] args) {
         Room room = new Room();
         Thread man = new Thread(room, "男人");
         Thread female = new Thread(room, "女人");
         System.out.println("After new but before start thread name = "+man.getName()+" state = "+man.getState());
         // 此时的man和female处于NEW状态
         man.start();
         System.out.println("After start Thread name ="+man.getName()+" state = "+man.getState());
         female.start();
         // 此时的man和female处于Runnable状态,但是等待相应的资源（比如IO或者时间片切换）才能开始执行,谁先获得资源就可以执行
         System.out.println("小姐已经接待完客人");
     }

 }

 class Room implements Runnable {
     public int count = 1;

     @Override
     public void run() {

         while (count <= 20) {
             // BLOCKED 阻塞状态，当遇到synchronized或者lock且没有取得相应的锁，就会进入这个状态
             synchronized (this) {
                 System.out.println(Thread.currentThread().getName() + "去小姐的房间,小姐累计接待客人:" + count + "个.");
                 count++;
                 try {
                     Thread.currentThread().sleep(100);
                     // this.wait(100);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }

     }

 }

结果：

 After new but before start thread name = 男人 state = NEW
 After start Thread name =男人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:1个.
 小姐已经接待完客人
 男人去小姐的房间,小姐累计接待客人:2个.
 男人去小姐的房间,小姐累计接待客人:3个.
 男人去小姐的房间,小姐累计接待客人:4个.
 男人去小姐的房间,小姐累计接待客人:5个.
 男人去小姐的房间,小姐累计接待客人:6个.
 男人去小姐的房间,小姐累计接待客人:7个.
 男人去小姐的房间,小姐累计接待客人:8个.
 男人去小姐的房间,小姐累计接待客人:9个.
 男人去小姐的房间,小姐累计接待客人:10个.
 男人去小姐的房间,小姐累计接待客人:11个.
 男人去小姐的房间,小姐累计接待客人:12个.
 男人去小姐的房间,小姐累计接待客人:13个.
 男人去小姐的房间,小姐累计接待客人:14个.
 男人去小姐的房间,小姐累计接待客人:15个.
 男人去小姐的房间,小姐累计接待客人:16个.
 男人去小姐的房间,小姐累计接待客人:17个.
 男人去小姐的房间,小姐累计接待客人:18个.
 男人去小姐的房间,小姐累计接待客人:19个.
 男人去小姐的房间,小姐累计接待客人:20个.
 女人去小姐的房间,小姐累计接待客人:21个.

从上面的结果可以看出，NEW状态在新创建一个线程时呈现，RUNNABLE是在线程调用start()方法。因为线程获得资源就可以执行，在main()方法中新建一个线程man.start()执行，因此新线程获得资源就可以执行，从第4行结果看出。

注意看最后面有一个女人。这是因为synchronized的代码同步时在while循环里面，因此最后一次男人和女人都进入到了while里面，然后才开始等待相应的锁。这就导致第20次执行完轮到了女人。

当调用wait时：

 @Override
     public void run() {

         while (count <= 20) {
             // BLOCKED 阻塞状态，当遇到synchronized或者lock且没有取得相应的锁，就会进入这个状态
 //            System.out.println("Before synchronized thread name = "+Thread.currentThread().getName()+" state = "+Thread.currentThread().getState());
             synchronized (this) {
                 System.out.println(Thread.currentThread().getName() + "去小姐的房间,小姐累计接待客人:" + count + "个.");
                 count++;
                 try {
 //                    Thread.currentThread().sleep(100);
                      this.wait(100);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }

结果：

 After new but before start thread name = 男人 state = NEW
 After start Thread name =男人 state = RUNNABLE
 小姐已经接待完客人
 男人去小姐的房间,小姐累计接待客人:1个.
 女人去小姐的房间,小姐累计接待客人:2个.
 男人去小姐的房间,小姐累计接待客人:3个.
 女人去小姐的房间,小姐累计接待客人:4个.
 8 女人去小姐的房间,小姐累计接待客人:5个.
 男人去小姐的房间,小姐累计接待客人:6个.
 女人去小姐的房间,小姐累计接待客人:7个.
 男人去小姐的房间,小姐累计接待客人:8个.
 男人去小姐的房间,小姐累计接待客人:9个.
 女人去小姐的房间,小姐累计接待客人:10个.
 男人去小姐的房间,小姐累计接待客人:11个.
 女人去小姐的房间,小姐累计接待客人:12个.
 男人去小姐的房间,小姐累计接待客人:13个.
 女人去小姐的房间,小姐累计接待客人:14个.
 男人去小姐的房间,小姐累计接待客人:15个.
 女人去小姐的房间,小姐累计接待客人:16个.
 男人去小姐的房间,小姐累计接待客人:17个.
 女人去小姐的房间,小姐累计接待客人:18个.
 男人去小姐的房间,小姐累计接待客人:19个.
 女人去小姐的房间,小姐累计接待客人:20个.

但是如果稍作修改就会出现弄一种情况，代码如下：

 class Room implements Runnable {
     public int count = 1;

     @Override
     public void run() {

         while (count <= 20) {
             // BLOCKED 阻塞状态，当遇到synchronized或者lock且没有取得相应的锁，就会进入这个状态
             System.out.println("Before synchronized thread name = "+Thread.currentThread().getName()+" state = "+Thread.currentThread().getState());
             synchronized (this) {
                 System.out.println(Thread.currentThread().getName() + "去小姐的房间,小姐累计接待客人:" + count + "个.");
                 count++;
                 try {
                     Thread.currentThread().sleep(100);
                     // this.wait(100);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }
         }

     }

结果：

 After new but before start thread name = 男人 state = NEW
 After start Thread name =男人 state = RUNNABLE
 Before synchronized thread name = 男人 state = RUNNABLE
 小姐已经接待完客人
 男人去小姐的房间,小姐累计接待客人:1个.
 Before synchronized thread name = 女人 state = RUNNABLE
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:2个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:3个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:4个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:5个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:6个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:7个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:8个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:9个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:10个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:11个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:12个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:13个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:14个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:15个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:16个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:17个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:18个.
 Before synchronized thread name = 女人 state = RUNNABLE
 男人去小姐的房间,小姐累计接待客人:19个.
 Before synchronized thread name = 男人 state = RUNNABLE
 女人去小姐的房间,小姐累计接待客人:20个.
 男人去小姐的房间,小姐累计接待客人:21个.

目前这种现象暂时还不是特别清楚原理，但是当男人和女人都在while循环等待时，Thread.currentThread().getName() 会获取当前线程的名字，而在循环中再获取当前名字时会出现这种交替的情况？其实Room资源一直是男人拥有。

三、Wait(), Notify() , NotifyAll()的使用

wait、notify、notifyall这几个一般都一起使用。不过需要注意下面几个重要的点：

1. 调用wait\notify\notifyall方法时，需要与锁或者synchronized搭配使用，不然会报错java.lang.IllegalMonitorStateException，因为任何时刻，对象的控制权只能一个线程持有，因此调用wait等方法的时候，必须确保对其的控制权。
2. 如果对简单的对象调用wait等方法，如果对他们进行赋值也会报错，因为赋值相当于修改的原有的对象，因此如果有修改需求可以外面包装一层。
3. notify可以唤醒一个在该对象上等待的线程，notifyAll可以唤醒所有等待的线程。
4. wait(xxx) 可以挂起线程，并释放对象的资源，等计时结束后自动恢复；wait()则必须要其他线程调用notify或者notifyAll才能唤醒。

 package springBootExample.example.simpleApplication;

 public class TestWaitAndNotify {
     Call call = new Call(false);

     class MaMa extends Thread {
         public MaMa(String name) {
             super(name);
         }

         @Override
         public void run() {
             synchronized (call) {
                 try {
                     call.wait(3000);
                 } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
                 call.setFlag(true);
                 // call.notifyAll();
                 for (int i = 0; i < 3; i++) {
                     System.out.println("进来一个吧");
                     call.notify();
                     try {
                         call.wait(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }

         }

     }

     class Customer extends Thread {
         public Customer(String name) {
             super(name);
         }

         @Override
         public void run() {
             synchronized (call) {
                 while (!call.isFlag()) {
                     System.out.println(Thread.currentThread().getName() + "等待王妈妈的呼唤");
                     try {
                         call.wait();
                     } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 }
                 System.out.println(Thread.currentThread().getName() + "进入小姐的房间");
             }
         }
     }

     public static void main(String[] args) {
         TestWaitAndNotify test = new TestWaitAndNotify();
         MaMa teacher = test.new MaMa("王妈妈");
         Customer stu1 = test.new Customer("小米");
         Customer stu2 = test.new Customer("小百");
         Customer stu3 = test.new Customer("小阿");
         teacher.start();
         stu1.start();
         stu2.start();
         stu3.start();

     }

 }

 class Call {
     private boolean flag = false;

     public Call(boolean flag) {
         this.flag = flag;
     }

     public boolean isFlag() {
         return flag;
     }

     public void setFlag(boolean flag) {
         this.flag = flag;
     }

 }

上面代码中21，24行包含了notify() 和notifyAll()方法的，61行注意内部类实例时的方法。代码的运行结果也会不相同，notify()输出的结果为：

小米等待王妈妈的呼唤
小阿等待王妈妈的呼唤
小百等待王妈妈的呼唤
进来一个吧
小米进入小姐的房间
进来一个吧
小阿进入小姐的房间
进来一个吧
小百进入小姐的房间

notifyAll()输出的结果为：

小米等待王妈妈的呼唤
小阿等待王妈妈的呼唤
小百等待王妈妈的呼唤
小百进入小姐的房间
小阿进入小姐的房间
小米进入小姐的房间

Reference

[1] http://www.cnblogs.com/xing901022/p/7846809.html