美文网首页
wait 和 sleep方法

wait 和 sleep方法

作者: 小时不识月z | 来源:发表于2018-06-29 08:21 被阅读88次

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

    线程的生命周期:线程是一个动态执行的过程,它也有一个产生到死亡的过程。

    1 新建 (new Thread)

    当创建Thread类的一个实例(对象)时,此线程进入新建状态(未被启动)。

    例如: Thread t1=new Thread();

    2 就绪(runnable)

    线程已经被启动,这个正在等待被分配给CPU时间片,也就是说此时线程正在就绪队列等候得到CPU资源。

    录入:t.start();

    3 运行(running)

    线程获得CPU资源正在执行任务(run()方法),此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入,线程将一直运行到结束。

    4 死亡(dead)

    当线程执行完毕或被其他线程杀死,线程就进入死亡状态,这时线程不可能再进入就绪状态等待执行。

    自然终止:正常运行run()方法后终止

    异常终止:调用stop()方法让一个线程终止运行

    5 堵塞(blocked)

    由于某种原因导致正在运行的线程让出CPU并暂停自己的执行,即进入堵塞状态。

    正在睡眠:用sleep(long t)方法可使线程进入睡眠方式。一个睡眠的线程再指定的时间过去可进入就绪状态。

    正在等待:调用wait()方法。(调用motify()方法回到就绪状态)

    被另一个线程锁阻塞:调用suspend()方法。(调用resume()方法恢复)

    重点出来了:

    第一种解释:

    功能差不多,都用来进行线程控制,他们最大本质的区别是:sleep()不释放同步锁,wait()释放同步锁。

    还有用法上的不同是sleep(milliseconds)可以用时间指定来是他自动醒过来,如果时间不到你只能调用interrupt()来强行打断;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不需要捕获异常

    相关文章

      网友评论

          本文标题:wait 和 sleep方法

          本文链接:https://www.haomeiwen.com/subject/josoeftx.html