sleep() 和wait() 有什么区别?_基础入门

8条回答

2楼 · 2020-12-16 14:01

sleep()是Thread类的静态方法，wait()属于Obejct类的成员方法；
sleep()可以不涉及线程通信，调用时指定这段时间此线程会暂停执行，但监控状态依然保持，不会释放对象锁，到时间自动恢复；wait()用于线程间的通信，调用时会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才进入对象锁定池准备获得对象锁进入运行状态；
wait()\notify()以及notifyAll()只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用；
sleep()方法必须捕获异常InterruptedException，wait()\notify()以及notifyAll()不需要捕获异常。

注意：
　　sleep方法只让出了CPU，而并不会释放同步资源锁。
　　线程执行sleep()方法后会转入阻塞状态。
　　sleep()方法指定的时间为线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。
　　notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度。

猜不到结尾

3楼 · 2020-12-16 09:56

sleep()是线程类Thread的方法；作用是导致此线程暂停执行指定时间，把执行机会给其他线程，但是监控状态依然保持，到时候会自动恢复；调用sleep()不会释放对象锁。

wait()是Object类的方法；对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池。只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池，准备获得对象锁进行运行状态。

yuixan

4楼 · 2020-12-16 11:01

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

flame

5楼 · 2020-12-16 11:06

sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程，但是监控状态依然保持，到时后会自动恢复。调用sleep不会释放对象锁。

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备获得对象锁进入运行状态。

1234567

6楼 · 2020-12-16 11:23

sleep()和wait()都是线程暂停执行的方法。

1、这两个方法来自不同的类分别是Thread和Object，sleep方法属于Thread类中的静态方法，wait属于Object的成员方法。

2、sleep()是线程类(Thread)的方法，不涉及线程通信，调用时会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复;wait()是Object的方法，用于线程间的通信，调用时会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才进入对象锁定池准备获得对象锁进入运行状态。

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

4、sleep()方法必须捕获异常InterruptedException，而wait()\notify()以及notifyAll()不需要捕获异常。

小小收藏家

7楼 · 2020-12-16 13:42

sleep()和wait()都是线程暂停执行的方法。

1、这两个方法来自不同的类分别是Thread和Object，sleep方法属于Thread类中的静态方法，wait属于Object的成员方法。
2、sleep()是线程类（Thread）的方法，不涉及线程通信，调用时会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；wait()是Object的方法，用于线程间的通信，调用时会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才进入对象锁定池准备获得对象锁进入运行状态。
3、wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用（使用范围）。
4、sleep()方法必须捕获异常InterruptedException，而wait()\notify()以及notifyAll()不需要捕获异常。

注意：

　　sleep方法只让出了CPU，而并不会释放同步资源锁。

　　线程执行sleep()方法后会转入阻塞状态。

　　sleep()方法指定的时间为线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

　　notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度。

灰机带翅膀

8楼 · 2020-12-20 13:57

结合synchronized，会更好的理解sleep()和wait()这两个方法，当然也就知道了他们的区别了。

sleep()

sleep() 方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。
因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。

下面用一个例子来演示：

Service类：

public class Service {    public void mSleep(){
        synchronized(this){            
        try{
                System.out.println(" Sleep 。当前时间："+System.currentTimeMillis());
                Thread.sleep(3*1000);
            }           
             catch(Exception e){
                System.out.println(e);
            }
        }
    }    
    public void mWait(){
        synchronized(this){
            System.out.println(" Wait 。结束时间："+System.currentTimeMillis());

        }
    }

}

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

SleepThread类：

public class SleepThread implements Runnable{

    private Service service;   
    public SleepThread(Service service){        
    this.service = service;
    }    
    public void run(){
        service.mSleep();
    }

}

线程类，用于调用Service 的mSleep方法

WaitThread类：

public class WaitThread implements Runnable{

    private Service service;    
    public WaitThread(Service service){        
    this.service = service;
    }    
    public void run(){
        service.mWait();
    }

}

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

测试类：

public class Test{    
public static void main(String[] args){

        Service mService = new Service();
        Thread sleepThread = new Thread(new SleepThread(mService));
        Thread waitThread = new Thread(new WaitThread(mService));
        sleepThread.start();
        waitThread.start();
    }
}

创建了一个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对象的其他同步代码块的，也就就是不能进入这一段代码

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

}

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

wait()

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

下面修改程序如下所示：

public class Service {    
public void mSleep(){
        synchronized(this){            
        try{
                Thread.sleep(3*1000);                
                this.notifyAll();
                System.out.println(" 唤醒等待 。 结束时间："+System.currentTimeMillis());
            }            
            catch(Exception e){
                System.out.println(e);
            }
        }
    }    public void mWait(){

        synchronized(this){            
        try{
                System.out.println(" 等待开始 。 当前时间："+System.currentTimeMillis());                this.wait();
            }
            catch(Exception e){
                System.out.println(e);
            }
        }
    }
}

测试类：

public class Test{    
public static void main(String[] args){
        Service mService = new Service();
        Thread sleepThread = new Thread(new SleepThread(mService));
        Thread waitThread = new Thread(new WaitThread(mService));
        waitThread.start();
        sleepThread.start();
    }
}

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

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

综上所诉：
sleep() 和 wait() 的区别就是调用sleep方法的线程不会释放对象锁，而调用wait() 方法会释放对象锁

我的网名不再改

9楼 · 2020-12-26 20:28

1、每个对象都有一个锁来控制同步访问，Synchronized关键字可以和对象的锁交互，来实现同步方法或同步块。sleep()方法正在执行的线程主动让出CPU（然后CPU就可以去执行其他任务），在sleep指定时间后CPU再回到该线程继续往下执行(注意：sleep方法只让出了CPU，而并不会释放同步资源锁！！！)；wait()方法则是指当前线程让自己暂时退让出同步资源锁，以便其他正在等待该资源的线程得到该资源进而运行，只有调用了notify()方法，之前调用wait()的线程才会解除wait状态，可以去参与竞争同步资源锁，进而得到执行。（注意：notify的作用相当于叫醒睡着的人，而并不会给他分配任务，就是说notify只是让之前调用wait的线程有权利重新参与线程的调度）；

2、sleep()方法可以在任何地方使用；wait()方法则只能在同步方法或同步块中使用；

3、sleep()是线程线程类（Thread）的方法，调用会暂停此线程指定的时间，但监控依然保持，不会释放对象锁，到时间自动恢复；wait()是Object的方法，调用会放弃对象锁，进入等待队列，待调用notify()/notifyAll()唤醒指定的线程或者所有线程，才会进入锁池，不再次获得对象锁才会进入运行状态；

举个列子说明：

public class ThreadTest {public static void main(String[] args) {new Thread(new Thread1()).start();try {Thread.sleep(5000);} catch (Exception e) {e.printStackTrace();}new Thread(new Thread2()).start();}public static class Thread1 implements Runnable {@Overridepublic void run() {synchronized (ThreadTest.class) {System.out.println("进入thread1...");System.out.println("thread1是等待...");try {//调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池ThreadTest.class.wait();} catch (Exception e) {e.printStackTrace();}System.out.println("thread1正在进行 ....");System.out.println("thread1结束!!!");}}}private static class Thread2 implements Runnable {@Overridepublic void run() {synchronized (ThreadTest.class) {System.out.println("进入thread2...");System.out.println("thread2是睡眠");//只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。ThreadTest.class.notify();//==================//区别//如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()//方法，则线程永远处于挂起状态。}try {//sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，//但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。//在调用sleep()方法的过程中，线程不会释放对象锁。Thread.sleep(5000);} catch (Exception e) {e.printStackTrace();}System.out.println("thread2正在进行....");System.out.println("thread2结束!!!");}}}

运行效果：

如果注释掉代码：

 ThreadTest.class.notify();