sleep() 和 wait() 的区别

 

结合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() 方法会释放对象锁