zoukankan      html  css  js  c++  java

  • sleep()和wait()的区别转

    Java中的多线程是一种抢占式的机制而不是分时机制。线程主要有以下几种状态：可运行，运行，阻塞，死亡。抢占式机制指的是有多个线程处于可运行状态，但是只有一个线程在运行。本文主要介绍sleep()和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不需要捕获异常

     

     

    Java中的多线程是一种抢占式的机制而不是分时机制。线程主要有以下几种状态：可运行，运行，阻塞，死亡。抢占式机制指的是有多个线程处于可运行状态，但是只有一个线程在运行。

    当有多个线程访问共享数据的时候，就需要对线程进行同步。线程中的几个主要方法的比较：

    Thread类的方法：sleep(),yield()等

    Object的方法：wait()和notify()等

    每个对象都有一个机锁来控制同步访问。Synchronized关键字可以和对象的机锁交互，来实现线程的同步。

    由于sleep()方法是Thread类的方法，因此它不能改变对象的机锁。所以当在一个Synchronized方法中调用sleep（）时，线程虽然休眠了，但是对象的机锁没有被释放，其他线程仍然无法访问这个对象。而wait()方法则会在线程休眠的同时释放掉机锁，其他线程可以访问该对象。

    Yield()方法是停止当前线程，让同等优先权的线程运行。如果没有同等优先权的线程，那么Yield()方法将不会起作用。

    一个线程结束的标志是：run()方法结束。

    一个机锁被释放的标志是：synchronized块或方法结束。

    Wait()方法和notify()方法：当一个线程执行到wait()方法时，它就进入到一个和该对象相关的等待池中，同时失去了对象的机锁。当它被一个notify()方法唤醒时，等待池中的线程就被放到了锁池中。该线程从锁池中获得机锁，然后回到wait()前的中断现场。

    join()方法使当前线程停下来等待，直至另一个调用join方法的线程终止。

    值得注意的是：线程的在被激活后不一定马上就运行，而是进入到可运行线程的队列中。

    共同点：他们都是在多线程的环境下，都可以在程序的调用处阻塞指定的毫秒数，并返回。

    不同点：Thread.sleep(long)可以不在synchronized的块下调用，而且使用Thread.sleep()不会丢失当前线程对任何对象的同步锁(monitor);

    object.wait(long)必须在synchronized的块下来使用，调用了之后失去对object的monitor, 这样做的好处是它不影响其它的线程对object进行操作。

    举个java.util.Timer的例子来说明。

    1. private void mainLoop() {  
    2. while (true) {  
    3. ....  
    4. synchronized(queue) {  
    5. .....  
    6. if (!taskFired) // Task hasn't yet fired; wait  
    7. queue.wait(executionTime - currentTime);  
    8. }  
    9. } 

    在这里为什么要使用queue.wait()，而不是Thread.sleep(), 是因为暂时放弃queue的对象锁，可以让允许其它的线程执行一些同步操作。如：

    1. private void sched(TimerTask task, long time, long period) {  
    2. synchronized(queue) {  
    3. ...  
    4. queue.add(task);  
    5. }  
    6. } 

    但是正如上篇文章讲到的，使用queue.wait(long)的前提条件是sched()动作执行的时间很短，否则如果很长，那么queue.wait()不能够按时醒来。

    前面讲了wait/notify机制，Thread还有一个sleep()静态方法，它也能使线程暂停一段时间。sleep与wait的不同点是：sleep并不释放锁，并且sleep的暂停和wait暂停是不一样的。obj.wait会使线程进入obj对象的等待集合中并等待唤醒。

    但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。

    如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。

    需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到wait()/sleep()/join()后，就会立刻抛出InterruptedException。

    下面是我原来在CSDN论坛上看到的一个贴子，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的一些回复和Think in Java上的相关概念将wait()和notify()这两个方法剖析了一下，欢迎指教.

     1 class ThreadA
 2 {
 3     public static void main(String[] args)
 4     {
 5         ThreadB b = new ThreadB();
 6         b.start();
 7         System.out.println("b is start....");
 8         synchronized (b)// 括号里的b是什么意思,起什么作用?
 9         {
10             try
11             {
12                 System.out.println("Waiting for b to complete...");
13                 b.wait();// 这一句是什么意思，究竟让谁wait?
14                 System.out.println("Completed.Now back to main thread");
15             } catch (InterruptedException e)
16             {
17             }
18         }
19         System.out.println("Total is :" + b.total);
20     }
21 }
22 
23 class ThreadB extends Thread
24 {
25     int total;
26 
27     public void run()
28     {
29         synchronized (this)
30         {
31             System.out.println("ThreadB is running..");
32             for (int i = 0; i < 100; i++)
33             {
34                 total += i;
35                 System.out.println("total is " + total);
36             }
37             notify();
38         }
39     }
40 }

    要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

    再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.

    按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态，同时又“积极”地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."

    我们来解释一下这句话.

    "wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和

    sleep,suspend有什么区别呢?

    区别在于"(wait)同时又“积极”地等待条件发生改变",这一点很关键,sleep和suspend无法做到.因为我们有时候需要通过同步（synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着,等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.

    而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.

    但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！

    好,那怎么把对象锁收回来呢?

    第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.

    第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?靠!当然用完了就收回了,还管我设的是多长时间啊.

    那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.

    因此，我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().

    这个时候我们来解释上面的程序,简直是易如反掌了.

    1. synchronized(b){...}； 

    的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.

    初识。。。在JAVA API。。。 

    Wait

    导致当前的线程等待，直到其他线程调用此对象的 notify方法或 notifyAll 方法。

    当前的线程必须拥有此对象监视器。该线程发布对此监视器的所有权并等待，直到其他线程通过调用 notify 方法，或 notifyAll 方法通知在此对象的监视器上等待的线程醒来。然后该线程将等到重新获得对监视器的所有权后才能继续执行。

    Sleep

    在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）。该线程不丢失任何监视器的所属权。

    Wait与Sleep。。。

    Wait是Object类的方法，范围是使该Object实例所处的线程。

    Sleep()是Thread类专属的静态方法，针对一个特定的线程。

    一般情况下在线程中若只是想暂停就可以不用wait，只要用Thread.sleep(...)这个方法，就像睡觉会睡过点一样，sleep的线程在时间结束后也不一定能够立即恢复执行。

    //线程A中
    try...{
        System.out.println(    "A will sleep");
            this.sleep();    
    }    catch(InterruptedException e)...{
             //A已经被中断了  
        System.out.println("A was interrupted");
    }

    //其他线程中
    A.interrupt();

    如果使用Wait方法需要通过Lock进行互斥，不然会抛出java.lang.IllegalMonitorStateException异常。

    private Object lock = new Object();
    ...
    synchronized (getLock()) ......{
        getLock().wait(timeout);
    }
    ...
    protected Object getLock() ......{
            return lock;
    }
    ...
    public void broadcast() ...{
           synchronized (getLock()) ...{
          getLock().notifyAll();
      }
    }

    上述实现了在一个Thread中使用wait等待的方法，由一个Fine-grain 锁来控制线程的互斥。

    Wait方法使实体所处线程暂停执行，从而使对象进入等待状态，直到被notify方法通知或者wait的等待的时间到。Sleep方法使持有的线程暂停运行，从而使线程进入休眠状态，直到用interrupt方法来打断他的休眠或者sleep的休眠的时间到。

    Wait方法进入等待状态时会释放同步锁(如上例中的lock对象)，而Sleep方法不会释放同步锁。所以，当一个线程无限Sleep时又没有任何人去interrupt它的时候，程序就产生大麻烦了。

    亲密。。。与notify。。。与interrupt。。。

    wait与notify。。。

    notify是用来通知线程，但在notify之前线程是需要获得lock的。另个意思就是必须写在synchronized(lockobj) {...}之中。wait也是这个样子，一个线程需要释放某个lock，也是在其获得lock情况下才能够释放，所以wait也需要放在synchronized(lockobj) {...}之中。看下下面的例子：

    //在线程A中
    synchronized(lockobject) ...{
    　　    while(!condition) ...{
    　　　　lockobject.wait();
    　　}
    　　    //TODO 该运行的部分
    }
    　　
    //在线程B中
    synchronized(lockobject) ...{
    　　condition     = true;
    　　lockobject.notify();
    }

    A线程获得lock之后不断的判断条件，不满足的时候就释放lock，进入等待。B获得lock，并且改变条件，之后通知A,之后B离开lock区，A获得lock执行该运行的部分。

    Sleep与notify。。。

    我感觉他们凑在一起没有任何的意义，因为线程在Sleep时并不会释放他占有的lock,所以notify并不能唤醒他。

    Sleep与interrupt。。。

    interrupt是个很暴力的方法，打断一个线程的Sleep时并不需要获得该线程的lock。虽然暴力却也有暴力的用处。在一个线程无时限sleep的时候也只有interrupt能够唤醒他。在interrupt的时候会抛出InterruptedException，这个Exception是由Thread 类自动抛出的。因此Interrupt带有强烈的阻塞味道。

    wait与interrupt。。。

    interrupt同样可以打断wait的等待，与打断sleep不同的是，被打断的wait的线程在重新获得lock之前是不会抛出InterruptedException。

    遗忘。。。resume与suspend。。。

    resume和suspend已经被Java遗弃，因为他们天生会引起线程的死锁。

    suspend是个贪婪的家伙，当一个线程在suspend的时候，线程会停下来，但却仍然持有在这之前获得的锁定。其他线程无法使用他锁定的任何资源，除非这个挂起的线程被resume之后，他才会继续运行。对于线程的同步，使用wait与notify要安全的多。

     
  • 相关阅读:
    全新的ASP.NET !
    asp.net core+ef core
    直播服务器Nginx
    NET Core1
    网络爬虫1
    java thread reuse（good）
    java中Executor、ExecutorService、ThreadPoolExecutor介绍（转）
    小心LinkedHashMap的get()方法（转）
    LinkedHashMap相关信息介绍（转）
    HashTable和HashMap的区别
  • 原文地址：https://www.cnblogs.com/WayneZeng/p/2992177.html
Copyright © 2011-2022 走看看