线程状态和线程等待唤醒机制解析

1、线程状态

1.1、线程状态划分

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态：

这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析。

1、Timed Waiting（计时等待）

Timed Waiting在API中的描述为：一个正在限时等待另一个线程执行一个（唤醒）动作的线程处于这一状态。单独的去理解这句话，真是玄之又玄，其实我们在之前的操作中已经接触过这个状态了，在哪里呢？在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
其实当我们调用了sleep方法之后，当前执行的线程就进入到“休眠状态”，其实就是所谓的Timed Waiting(计时等待)，那么我们通过一个案例加深对该状态的一个理解。

2、Blocked（锁阻塞）

Blocked状态在API中的介绍为：一个正在阻塞等待一个监视器锁（锁对象）的线程处于这一状态。我们已经学完同步机制，那么这个状态是非常好理解的了。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么线程B就进入到Blocked锁阻塞状态。这是由Runnable状态进入Blocked状态。除此Waiting以及Time Waiting状态也会在某种情况下进入阻塞状态，而这部分内容作为扩充知识点带领大家了解一下。

3、Waiting（无限等待）

Wating状态在API中介绍为：一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。当多个线程协作时，比如A，B线程，如果A线程在Runnable（可运行）状态中调用了wait()方法那么A线程就进入了Waiting（无限等待）状态，同时失去了同步锁。假如这个时候B线程获取到了同步锁，在运行状态中调用了notify()方法，那么就会将无限等待的A线程唤醒。注意是唤醒，如果获取到锁对象，那么A线程唤醒后就进入Runnable（可运行）状态；如果没有获取锁对象，那么就进入到Blocked（锁阻塞状态）。

1.2、线程状态的相互转化

常见的线程状态转换关系为：

考虑到Timed Waiting（计时等待）状态的转换图为：

我们在翻阅API的时候会发现Timed Waiting（计时等待） 与 Waiting（无限等待） 状态联系还是很紧密的，比如Waiting（无限等待） 状态中wait方法是空参的，而timed waiting（计时等待） 中wait方法是带参的。这种带参的方法，其实是一种倒计时操作，相当于我们生活中的小闹钟，我们设定好时间，到时通知，可是如果提前得到（唤醒）通知，那么设定好时间在通知也就显得多此一举了，那么这种设计方案其实是一举两得。如果没有得到（唤醒）通知，那么线程就处于Timed Waiting状态,直到倒计时完毕自动醒来；如果在倒计时期间得到（唤醒）通知，那么线程从Timed Waiting状态立刻唤醒。

2、线程等待唤醒机制

2.1、线程通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。

为什么要处理线程间通信：

多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时， 避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

2.2、等待唤醒机制

什么是等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争（race），比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。就好比在公司里你和你的同事们，你们可能存在在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。

就是在一个线程进行了规定操作后，就进入等待状态（wait()）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify()）;在有多个线程进行等待时， 如果需要，可以使用 notifyAll()来唤醒所有的等待线程。

wait/notify 就是线程间的一种协作机制。

等待唤醒中的方法

等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：

1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING。它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先入座。
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：

哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：

• 如果能获取锁，线程就从 Waiting 状态变成 Runnable 状态；
• 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 Blocked 状态

调用wait和notify方法需要注意的细节

1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

2.3、生产者与消费者问题

等待唤醒机制其实就是经典的“生产者与消费者”的问题。
就拿生产包子消费包子来说等待唤醒机制如何有效利用资源：

包子铺线程生产包子，吃货线程消费包子。当包子没有时（包子状态为false），吃货线程等待，包子铺线程生产包子（即包子状态为true），并通知吃货线程（解除吃货的等待状态）,因为已经有包子了，那么包子铺线程进入等待状态。接下来，吃货线程能否进一步执行则取决于锁的获取情况。如果吃货获取到锁，那么就执行吃包子动作，包子吃完（包子状态为false），并通知包子铺线程（解除包子铺的等待状态）,吃货线程进入等待。包子铺线程能否进一步执行则取决于锁的获取情况。

2.4、生产者与消费者问题模拟

包子资源类：

package communicate_thread;

public class BaoZi {
    //包子皮
    String pi;
    //包子馅
    String xian;
    //包子是否存在的状态类，初始设置为没有
    boolean flag = false;
}

吃货线程类：

package communicate_thread;

public class ChiHuo extends Thread {
    private BaoZi baoZi;

    public ChiHuo(BaoZi baoZi){
        this.baoZi = baoZi;
    }

    public void run(){
        while(true){
            //同步代码块，保证线程安全
            synchronized (baoZi){
                if(baoZi.flag == false){
                    try{
                        //没有包子，阻塞吃货线程，使得吃货等待包子铺线程生产包子
                        baoZi.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    //有包子的状态，吃货执行的吃包子操作
                    System.out.println("吃货正在吃包子："+baoZi.pi+" : "+baoZi.xian);
                    //吃货吃完包子，此时将包子设置为没有的状态
                    baoZi.flag = false;
                    //唤醒包子铺线程，使得包子铺生产包子
                    baoZi.notify();
                    System.out.println("吃货已经吃完了包子："+baoZi.pi+" : "+baoZi.xian);
                    System.out.println("------------------------------------");
                }
            }
        }
    }
}

包子铺线程类：

package communicate_thread;

public class BaoZiPu extends Thread{
    private BaoZi baoZi;

    public BaoZiPu(BaoZi baoZi) {
        this.baoZi = baoZi;
    }

    public void run(){
        //定义包子种类判断变量
        int count = 0;
        while(true){
            //同步代码块，保证线程安全
            synchronized (baoZi){
                //对包子的状态进行判断
                if(baoZi.flag == true){
                    try{
                        //有包子的状态，阻塞包子铺线程生产包子
                        baoZi.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
                //判断包子种类
                if(count%2 == 0){
                    baoZi.pi = "薄皮";
                    baoZi.xian = "三鲜馅";
                }else{
                    baoZi.pi = "冰皮";
                    baoZi.xian = "牛肉大葱馅";
                }
                //轮流生产两种包子
                count++;
                //包子状态为没有状态，则包子铺生产包子
                System.out.println("包子铺的包子正在生产："+baoZi.pi+" : "+baoZi.xian);
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                //包子铺生产完包子，修改包子的状态为有的状态
                baoZi.flag = true;
                //唤醒吃货线程，让吃货吃包子
                baoZi.notify();
                System.out.println("包子铺的包子已经生产好了："+baoZi.pi+" : "+baoZi.xian);
            }
        }
    }
}

测试类：

package communicate_thread;

public class TestDemo1 {
    public static void main(String[] args) {
        BaoZi baoZi = new BaoZi();
        new ChiHuo(baoZi).start();
        new BaoZiPu(baoZi).start();
    }
}

执行结果：