操作系统的种状态切换图，搞懂操作系统的状态切换

阻塞状态（Blocked）当任务等待某个事件或信号的时候处于此状态
挂起状态（Suspended）当任务被vTaskSuspend()函数禁止运行的时候处于此状态
就绪状态（Ready）当任务没有被阻塞或者挂起等待运行的时候处于此状态
运行状态（Running）当任务被内核调度执行的时候处于此状态

sleep和wait的区别：
当任务执行延时命令或者等待某个同步事件的时候便交出了自己的运行权，此时将处于阻塞状态（Blocked）。
sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。
一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，意思是等待时间即使到了，资源不够用也是没有用的。
等待是让出资源，在线程池等待，所以需要有一个notify唤醒线程，举例：

public class ThreadTestffd { 
    private Integer num = 0;
    private Integer result=0;
    public static void main(String[] args) {
        ThreadTestffd test = new ThreadTestffd();
        test.A();
        test.B();
    } 
    public void A() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("A线程准备");
 
 
                synchronized (result) {
                    System.out.println("A线程开始");
                    try {
                        result.wait();
                        //Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int i = 0; i < 10; i++) {
                        System.out.println("a" +result++);
                    
                    }
                }
            }
        }).start();
    } 
    public void B() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("B线程准备");
            {
                    System.out.println("B线程开始");
//                  for (int i = 0; i < 10; i++) {
//                      System.out.println("b" +(result++));
////                        try {
////                            Thread.sleep(1000);
////                        } catch (InterruptedException e) {
////                            e.printStackTrace();
////                        }
//                  }
//    result++;                 
                    while(true)
                    {
                    num++;
                    if(num==3){
                        {                           
                            try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                            synchronized (result) //获取对象锁
                            {
                                System.out.println("numb"+num);
                                result.notify();//唤醒线程
                                break;
                            }   
                        }                       
                    }
                    else{
                        continue;
                    }                       
                }
                    }
            }
        }).start();
    } 
}

结果：线程a等待，开启线程b，当线程b将num累加到3的时候，唤醒线程a，同时结束线程b

拓展：如果添加的是，result.wait(1000);
这个时候就有一个优先过程，如果是b线程唤醒在前，那么就不用等待1s，如果是b线程sleep时间太长，那么a线程等待1s后直接直接执行a线程。

result.notifyAll();//唤醒所有线程，可以唤醒除了resut的锁。