java的线程状态概述

线程的状态分类

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在API中java.lang.Thread.State这个枚举中给出了六种线程状态：这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解

线程状态	导致状态发生条件
NEW(新建)	线程刚被创建，但是并未启动。还没调用start方法。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
TimedWaiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入TimedWaiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

状态之间的转换

线程从Runnable（可运行）状态与非运行状态之间的转换问题

wait和notify的使用

等待唤醒案例:线程之间的通信
    创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待)
    创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子

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

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

package cn.itcast.day02.demo08;

public class Waitdemo {
    public static void main(String[] args) {
        Object obj=new Object();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (obj){
                        System.out.println("告诉老板，需要的包子种类和数量");
                        //只能使用try...catch，因为父类没有抛出异常，子类不能throw，
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("我要开始吃了");
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
               while(true){
                   try {
                       Thread.sleep(5000);//还5秒做包子
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   synchronized (obj){
                       System.out.println("老板在5秒后，做好包子了，告诉顾客来吃包子");
                       obj.notify();
                   }
               }

            }
        }.start();
    }
}

告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
我要开始吃了
告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
我要开始吃了
告诉老板，需要的包子种类和数量
...

wait带参数方法和notifyAll方法

进入到TimeWaiting(计时等待)有两种方式
1.使用【sleep】(long m)方法,在毫秒值结束之后,线程睡醒进入到Runnable/Blocked状态
2.使用【wait】(long m)方法,wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

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

【wait(毫秒数)】
自己醒了。wait方法如果在毫秒值结束之后,还没有被notify唤醒,就会自动醒来,线程睡醒进入到Runnable/Blocked状态

package cn.itcast.day02.demo08;
public class Waitdemo {
    public static void main(String[] args) {
        Object obj=new Object();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (obj){
                        System.out.println("告诉老板，需要的包子种类和数量");
                        //只能使用try...catch，因为父类没有抛出异常，子类不能throw，
                        try {
                            obj.wait(500);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("我要开始吃了");
                    }
                }
            }
        }.start();
    }
}

告诉老板，需要的包子种类和数量
我要开始吃了
告诉老板，需要的包子种类和数量
我要开始吃了
告诉老板，需要的包子种类和数量
我要开始吃了

【notify】
唤醒在此对象监视器上等待的单个线程。

package cn.itcast.day02.demo08;
public class Waitdemo {
    public static void main(String[] args) {
        Object obj=new Object();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (obj){
                        System.out.println("顾客一：告诉老板，需要的包子种类和数量");
                        //只能使用try...catch，因为父类没有抛出异常，子类不能throw，
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("顾客一：我要开始吃了");
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (obj){
                        System.out.println("顾客二：告诉老板，需要的包子种类和数量");
                        //只能使用try...catch，因为父类没有抛出异常，子类不能throw，
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("顾客二：我要开始吃了");
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(5000);//还5秒做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj){
                        System.out.println("老板在5秒后，做好包子了，告诉顾客来吃包子");
                        obj.notify();
                    }
                }

            }
        }.start();
    }
}

顾客一：告诉老板，需要的包子种类和数量
顾客二：告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
顾客一：我要开始吃了
顾客一：告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
顾客二：我要开始吃了
顾客二：告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
顾客一：我要开始吃了
顾客一：告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
顾客二：我要开始吃了

【notifyAll】
唤醒在此对象监视器上等待的所有线程。

package cn.itcast.day02.demo08;
public class Waitdemo {
    public static void main(String[] args) {
        Object obj=new Object();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (obj){
                        System.out.println("顾客一：告诉老板，需要的包子种类和数量");
                        //只能使用try...catch，因为父类没有抛出异常，子类不能throw，
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("顾客一：我要开始吃了");
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    synchronized (obj){
                        System.out.println("顾客二：告诉老板，需要的包子种类和数量");
                        //只能使用try...catch，因为父类没有抛出异常，子类不能throw，
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("顾客二：我要开始吃了");
                    }
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(5000);//还5秒做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj){
                        System.out.println("老板在5秒后，做好包子了，告诉顾客来吃包子");
                        obj.notifyAll();
                    }
                }

            }
        }.start();
    }
}

顾客一：告诉老板，需要的包子种类和数量
顾客二：告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
顾客一：我要开始吃了
顾客一：告诉老板，需要的包子种类和数量
顾客二：我要开始吃了
顾客二：告诉老板，需要的包子种类和数量
老板在5秒后，做好包子了，告诉顾客来吃包子
顾客一：我要开始吃了
顾客一：告诉老板，需要的包子种类和数量
顾客二：我要开始吃了
顾客二：告诉老板，需要的包子种类和数量