java中sleep()和wait()的区别

sleep()方法

　　1、sleep()方法是线程类（Thread）的静态方法,它能让调用的线程进入睡眠状态，让出cpu的执行机会给其它线程执行，等到休眠时间结束后，线程就会进行就绪状态，和其它线程一起竞争cpu的执行机会。也就说如是休眠时间结束后cpu在执行其它线程，此时这个线程必须等待那个线程执行完后才会执行。

　　2、因为sleep()是静态方法，它不能改变对象的机锁，当一个synchronized(线程同步块)中调用了sleep()方法，线程虽然进入了休眠状态，但线程的机锁并没有被释放，其它线程任然无法访问该对象。

Service类

 1 public class Service {
 2 
 3     public void mSleep(){
 4         synchronized(this){
 5             try{
 6                 System.out.println(" Sleep 。当前时间："+System.currentTimeMillis());
 7                 Thread.sleep(3*1000);
 8             }
 9             catch(Exception e){
10                 System.out.println(e);
11             }
12         }
13     }
14 
15     public void mWait(){
16         synchronized(this){
17             System.out.println(" Wait 。结束时间："+System.currentTimeMillis());
18 
19         }
20     }
21 
22 }

这里就定义了两个方法， mSleep()方法会让调用线程休眠3秒，mWait() 就打印一句话。两个方法都使用了同步锁。

SleepThread类：线程类，调用Service的mSleep方法

public class SleepThread implements Runnable{

    private Service service;

    public SleepThread(Service service){
        this.service = service;
    }

    public void run(){
        service.mSleep();
    }

}

WaitThread类：线程类，用于调用Service的mWait方法

 1 public class WaitThread implements Runnable{
 2 
 3     private Service service;
 4 
 5     public WaitThread(Service service){
 6         this.service = service;
 7     }
 8 
 9     public void run(){
10         service.mWait();
11     }
12 
13 }

测试类：

 1 public class Test{
 2     public static void main(String[] args){
 3 
 4         Service mService = new Service();
 5 
 6         Thread sleepThread = new Thread(new SleepThread(mService));
 7         Thread waitThread = new Thread(new WaitThread(mService));
 8         sleepThread.start();
 9         waitThread.start();
10 
11     }
12 
13 }

创建了一个Service对象并赋值给mService，还创建了两个线程并传入mService，也就是说两个线程启动后，调用的是同一个Service对象的方法。
先看下结果：
这里写图片描述

梳理一下逻辑：

首先sleepThread线程会启动起来，然后在run方法里调用Service对象的mSleep方法，到了同步代码块后，this就是Test类里创建的Service对象mService，sleepThread线程获得了Service对象的锁，之后进入了休眠状态，但并没有释放该Service对象的锁。
这时waitThread线程也启动了起来，调用Service对象的mWait方法，同样到了同步代码块，因为Service对象的锁已经被sleepThread占了，所以waitThread线程只能干等着。
等到sleepThread线程执行完毕（休眠结束）后释放了同步锁，waitThread线程拿到了同步锁，会继续执行，mWait才会被调用。

如果sleepThread释放了机锁的话，waitThread 的任务会马上得到执行。从打印结果可以看出，waitThread 的任务是3秒钟之后才得到执行。

同步锁，锁住的是一个对象。如果一个线程拿到了一个对象的机锁去执行一段同步代码块了，那么其他线程都不能执行这个对象的其他同步代码块。
在这个例子中就是sleepThread线程拿到了service对象的同步锁，进入后休眠，但没有释放机锁，那么waitThread线程是不能执行这个service对象的其他同步代码块的，也就就是不能进入这一段代码

1 synchronized(this){
2     System.out.println(" Wait 。结束时间："+System.currentTimeMillis());
3 
4 }

相信现在你已经理解了sleep方法没有释放机锁会带来什么结果了，那么继续wait

wait()

wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程

下面修改程序如下所示：

 1 public class Service {
 2 
 3     public void mSleep(){
 4         synchronized(this){
 5 
 6             try{
 7                 Thread.sleep(3*1000);
 8                 this.notifyAll();
 9                 System.out.println(" 唤醒等待 。 结束时间："+System.currentTimeMillis());
10             }
11             catch(Exception e){
12                 System.out.println(e);
13             }
14 
15         }
16 
17     }
18 
19     public void mWait(){
20 
21         synchronized(this){
22             try{
23                 System.out.println(" 等待开始 。 当前时间："+System.currentTimeMillis());
24                 this.wait();
25             }catch(Exception e){
26                 System.out.println(e);
27             }
28         }
29 
30     }
31 
32 }

测试类：

 1 public class Test{
 2 
 3     public static void main(String[] args){
 4 
 5         Service mService = new Service();
 6 
 7         Thread sleepThread = new Thread(new SleepThread(mService));
 8         Thread waitThread = new Thread(new WaitThread(mService));
 9         waitThread.start();
10         sleepThread.start();
11 
12     }
13 
14 }

同样先看下打印结果
这里写图片描述

这里是先让 waitThread线程启动起来，然后waitThread线程进入等待状态，并释放了Service对象的锁，这时sleepThread也启动了，来到了mSleep方法的同步代码块，因为之前的waitThread线程已经释放了Service对象的机锁，sleepThread可以拿到对象锁，所以mSleep方法是会被马上调用的。然后sleepThread线程就是进入了睡眠状态，等到3秒休眠结束后调用notifyAll()唤醒了waitThread线程。

总结：

　　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不需要捕获异常