线程状态

1.线程的六种状态

1.1计时等待状态（Timed Waiting）

等待一定时间后（一般是提前设置好得），根据CPU的情况回到运行态或阻塞态

1.2锁阻塞状态

未获得锁对象进入到锁阻塞状态

1.3无线等待状态（WAITING）

一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态。

1.4等待唤醒实例

需求：
创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃CPU的执行，进入到WAITING状态
创建一个老板线程（生产者）：花费5秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子

注意“
顾客和老板的线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保持统一
只有锁对象才能使用wait和notify方法。

void wait（）：在其他线程调用此对象的notify（）方法或notifyAll方法前，导致当前线程等待
void notify（）：唤醒在此对象监视器上等待的单个线程。
会继续执行wai之后的代码

package xc;

public class demo02 {
    public static void main(String[] args) {
        //创建锁对象
        Object obj = new Object();
        //创建顾客线程
        new Thread() {
            @Override
            public void run() {
                synchronized (obj) {
                    System.out.println("我需要的包子");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("真好吃");
                }
            }
        }.start();
        //创建老板的线程
        new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj){
                    System.out.println("ok了");
                    obj.notify();
                }

            }
        }.start();
    }

}

我需要的包子
ok了
真好吃

1.5等待和唤醒方法

1.进入到Timewaiting（计时等待）有两种方法

• 使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
• 使用wait（long m）方法，wait方法在毫秒值结束后，还没有被notify唤醒,就会自动醒来

2.唤醒方法

• void notify()唤醒在此对象监视器上等待的单个线程
• void notifyAll() 唤醒在此对象监视器上等待的所有线程

2.线程间的通信

2.1等待与唤醒机制

2.1.1什么是等待唤醒机制

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争( race) , 比如去争夺锁,但这并不是故事的全部,线程间也会有协作机制。就好比在公司里你和你的同事们,你们可能存在在晋升时的竞争,但更多时候你们更多是一起合作以完成某些任务。就是在一一个线程进行了规定操作后,就进入等待状态( wait() )，等待其他线程执行完他们的指定代码过后就是在一一个线程进行了规定操作后,就进入等待状态( wait() )，等待其他线程执行完他们的指定代码过后就是在一一个线程进行了规定操作后,就进入等待状态( wait() )，等待其他线程执行完他们的指定代码过后

2.1.2 等待唤醒中的方法

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

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

注意：

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

2.2 等待与唤醒案例：

1.资源类

package xc;

public class ziyuan {
    String name;
    String mood;
    boolean zhuangtai = false;

    public ziyuan(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMood() {
        return mood;
    }

    public void setMood(String mood) {
        this.mood = mood;
    }

    public boolean isZhuangtai() {
        return zhuangtai;
    }

    public void setZhuangtai(boolean zhuangtai) {
        this.zhuangtai = zhuangtai;
    }
}

2.消费者

package xc;

public class consumer implements Runnable {
    private ziyuan re;

    public consumer(ziyuan re) {
        this.re = re;
    }

    @Override
    public void run() {
        while(true){
            synchronized (re){
                if(re.zhuangtai==false){
                    try {
                        re.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                System.out.println("吃包子");
                re.zhuangtai=false;
                re.notify();

            }
        }
    }
}

3.生产者

package xc;

public class producer implements Runnable{
    private ziyuan re;

    public producer(ziyuan re) {
        this.re = re;
    }

    @Override
    public void run() {
        while(true){
            synchronized (re){
                if(re.zhuangtai==true){
                    try {
                        re.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else {
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    re.zhuangtai=true;
                    re.notify();
                    System.out.println("包子好了");

                }
            }
        }

    }
}

4.主方法

package xc;

public class dome {
    public static void main(String[] args) {
        ziyuan re = new ziyuan("牛肉包子");
        new Thread(new producer(re)).start();
        new Thread(new consumer(re)).start();
    }
}

5.结果：

包子好了
吃包子
包子好了
吃包子
包子好了
吃包子
包子好了
吃包子
包子好了
吃包子
...