java中的sleep和wait的区别

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java中的sleep和wait的区别相关的知识,希望对你有一定的参考价值。

sleep和wait的区别:

1、sleep的意思是:睡,睡觉,睡眠。

2、wait的意思是:等候,推迟,延缓等待,耽搁,伺候用餐。

拓展资料

sleep的用法

1、They were exhausted from lack of sleep 

由于缺乏睡眠,他们非常疲惫。

2、During the car journey, the baby slept 

坐车来的路上,宝宝睡着了。

3、I think he may be ready for a sleep soon. 

我想他也许很快就要睡一觉了。

4、I can't get to sleep with all that singing. 

那些歌声搅得我无法入睡。

5、I didn't lose too much sleep over that investigation. 

我并不太担心那个调查。

wait

1、I walk to a street corner and wait for the school bus 

我走到街角等校车。

2、There'll be a car waiting for you 

会有辆汽车等你。

3、I want to talk to you, but it can wait 

我想和你谈谈,但可以晚点再说。

4、If you think this all sounds very exciting, just wait until you read the book 

如果你觉得所有这些听起来令人兴奋,那就等着去读这本书吧。

5、'Wait a minute!' he broke in. 'This is not giving her a fair hearing!' 

“等一下,”他插嘴说,“这没有给她一个公平的解释机会!”

参考技术A sleep()和wait()的区别

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的例子来说明。

private void mainLoop()
while (true)
....
synchronized(queue)
.....
if (!taskFired) // Task hasn't yet fired; wait
queue.wait(executionTime - currentTime);


在这里为什么要使用queue.wait(),而不是Thread.sleep(), 是因为暂时放弃queue的对象锁,可以让允许其它的线程执行一些同步操作。如:
private void sched(TimerTask task, long time, long period)
synchronized(queue)
...
queue.add(task);


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

(2)
前面讲了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。

sleep()、suspend()、resume()方法不推荐使用,推荐使用wait()、notify()、notifyAll()。
sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后,线程不一定立即恢复执行。这是因为在那个时刻,其它线程可能正在运行而且没有被调度为放弃执行,除非
(a)“醒来”的线程具有更高的优先级。
(b)正在运行的线程因为其它原因而阻塞。
wait()是线程交互时,如果线程对一个同步对象x 发出一个wait()调用,该线程会暂停执行,被调对象进入等待状态,直到被唤醒或等待时间到。
当调用wait()后,线程会释放掉它所占有的“锁标志”,从而使线程所在对象中的其它synchronized数据可被别的线程使用。
waite()和notify()因为会对对象的“锁标志”进行操作,所以它们必须在synchronized函数或synchronized block中进行调用。如果在non-synchronized函数或non-synchronized block中进行调用,虽然能编译通过,但在运行时会发生IllegalMonitorStateException的异常。本回答被提问者采纳
参考技术B sleep是在规定时间后自动进入就绪状态
wait是通过notify唤醒进入就绪状态

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

  • 这两个方法来自不同的类分别是Thread和Object  
  • 最主要是sleep方法没有释放锁,而wait方法释放了锁,使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。
  • wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用(使用范围)  
  • sleep必须捕获异常,而wait,notify和notifyAll不需要捕获异常  

例子

package wait_sleep;

/**
 * java中的sleep()和wait()的区别
 * @author Hongten
 * @date 2013-12-10
 */
public class TestD {
    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();
    }

    private static class Thread1 implements Runnable{
        @Override
        public void run(){
            synchronized (TestD.class) {
                System.out.println("enter thread1...");
                System.out.println("thread1 is waiting...");
                try {
                    //调用wait()方法,线程会放弃对象锁,进入等待此对象的等待锁定池
                    TestD.class.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("thread1 is going on ....");
                System.out.println("thread1 is over!!!");
            }
        }
    }

    private static class Thread2 implements Runnable{
        @Override
        public void run(){
            synchronized (TestD.class) {
                System.out.println("enter thread2....");
                System.out.println("thread2 is sleep....");
                try {
                    //在调用sleep()方法的过程中,线程不会释放对象锁。
                    Thread.sleep(5000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("thread2 is going on....");
                System.out.println("thread2 is over!!!");
                //如果我们把代码:TestD.class.notify();给注释掉,即TestD.class调用了wait()方法,但是没有调用notify()
                //方法,则线程永远处于挂起状态。
                TestD.class.notify();
            }
        }
    }
}

 

以上是关于java中的sleep和wait的区别的主要内容,如果未能解决你的问题,请参考以下文章

java中的sleep和wait的区别

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

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

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

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

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