sleep() 和 wait() 有什么区别? sleep和wait 都用在什么方面
请各位举个例子
一直没弄明白 有些疑惑

sleep()是需要设置时间，时间到了就醒了。而wait()了就一直被wait了，必须有另一个线程唤醒，否则一直wait.

1、这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。

sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。


2、最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。

Thread.Sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。


3、使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }


4、sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

sleep是线程被调用时，占着cpu去睡觉，其他线程不能占用cpu，os认为该线程正在工作，不会让出系统资源，wait是进入等待池等待，让出系统资源，其他线程可以占用cpu，一般wait不会加时间限制，因为如果wait的线程运行资源不够，再出来也没用，要等待其他线程调用notifyall方法唤醒等待池中的所有线程，才会在进入就绪序列等待os分配系统资源， sleep是静态方法，是谁掉的谁去睡觉，就算是在main线程里调用了线程b的sleep方法，实际上还是main去睡觉，想让线程b去睡觉要在b的代码中掉sleep
给你看个例子
class SimpleSleep {
    public static void main(String[] args) {

        aMethod();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            // 执行到这里的机率非常低
        }

        anotherMethod();
    }

    public static void aMethod() {
        System.out.println("执行 aMethod");
    }

    public static void anotherMethod() {
        System.out.println("执行 anotherMethod");
    }
}

sleep() 、睡眠的意思。sleep(3000) ,括号里指毫秒、当线程走到这里时候、就会进入睡眠状态、并且拿着cpu权限。当时间到的时候就继续运行，
而wait();  就是等待的意思。运行到这里会释放cpu权、并且等待唤醒、如果没有被唤醒将一直处于冻结状态。

1. class MyThread extends Thread{
   
2.         public void run(){
   
3.                 try {
   
4.                         Thread.currentThread().sleep(3000);
   
5.                 } catch (InterruptedException e) {
   
6.                 }
   
7.                 System.out.println("MyThread running");
   
8.         }
   
9. }
   
10. 
    
11. public class ThreadTest{
    
12.         public static void main(String argv[]) {
    
13.                 MyThread t = new MyThread();
    
14.                 t.start();
    
15.                 System.out.println("Thread Test");
    
16.           }
    
17. }

复制代码

sleep和wait之间的区别：
第一种解释：

功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步缩.   
   
  还有用法的上的不同是:sleep(milliseconds)可以用时间指定来使他自动醒过来,如果时间不到你只能调用interreput()来强行打断;wait()可以用notify()直接唤起.

第二种解释：

sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间，在时间到达时恢复，也就是说sleep将在接到时间到达事件事恢复线程执行，例如：

try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}


wait是Object的方法，也就是说可以对任意一个对象调用wait方法，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify方法才会重新激活调用者，例如：


//Thread 1

try{
obj.wait();//suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}

第三种解释：

这两者的施加者是有本质区别的.
sleep()是让某个线程暂停运行一段时间,其控制范围是由当前线程决定,也就是说,在线程里面决定.好比如说,我要做的事情是 "点火->烧水->煮面",而当我点完火之后我不立即烧水,我要休息一段时间再烧.对于运行的主动权是由我的流程来控制.

而wait(),首先,这是由某个确定的对象来调用的,将这个对象理解成一个传话的人,当这个人在某个线程里面说"暂停!",也是 thisOBJ.wait(),这里的暂停是阻塞,还是"点火->烧水->煮饭",thisOBJ就好比一个监督我的人站在我旁边,本来该线 程应该执行1后执行2,再执行3,而在2处被那个对象喊暂停,那么我就会一直等在这里而不执行3,但正个流程并没有结束,我一直想去煮饭,但还没被允许, 直到那个对象在某个地方说"通知暂停的线程启动!",也就是thisOBJ.notify()的时候,那么我就可以煮饭了,这个被暂停的线程就会从暂停处 继续执行.


其实两者都可以让线程暂停一段时间,但是本质的区别是一个线程的运行状态控制,一个是线程之间的通讯的问题

在java.lang.Thread类中，提供了sleep()，
而java.lang.Object类中提供了wait()， notify()和notifyAll()方法来操作线程
sleep()可以将一个线程睡眠，参数可以指定一个时间。
而wait()可以将一个线程挂起，直到超时或者该线程被唤醒。
    wait有两种形式wait()和wait(milliseconds).
sleep和wait的区别有：
  1，这两个方法来自不同的类分别是Thread和Object
  2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
  3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
    任何地方使用
   synchronized(x){
      x.notify()
     //或者wait()
   }
   4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

1.sleep必须指定时间，wait可以不指定
2.wait必须定义在同步中，sleep不一定
3.sleep释放执行权，不释放锁。wait释放执行权，释放锁
比如生产者消费者问题，set里wait（）释放锁的同时释放执行权，唤醒out，所以会到out里去消费。如果把set换成sleep就不释放执行权，sleep过后继续生产
class Resource
{
        private String name;
        private int count;
        private boolean flag;
        public synchronized void set(String name)
        {
                if(flag)
                        try{this.wait();}catch(Exception e){}
                this.name = name+count;
                count++;

                System.out.println(Thread.currentThread().getName()+"....生产者..."+this.name);

                flag = true;
                notify();
        }

        public synchronized void out()
        {
                if(!flag)
                        try{this.wait();}catch(Exception e){}
                System.out.println(Thread.currentThread().getName()+"......消费者......."+this.name);
                flag = false;
                notify();
        }

}


class Producer implements Runnable
{
        private Resource r;
        Producer(Resource r)
        {
                this.r = r;       
        }
        public void run()
        {
                while(true)
                {
                        r.set("商品");
                }
        }
}