黑马程序员技术交流社区

标题: 线程学习，sleep()和wait()的区别 [打印本页]
作者: yunfeng482    时间: 2016-3-13 13:54
标题: 线程学习，sleep()和wait()的区别
sleep:Thread 类中定义的方法，表示线程休眠，会自动唤醒。
wait：Object中定义的方法，需要手动调用notify（）或者notifyAll（）方法。

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


sleep就是正在执行的线程主动让出cpu，cpu去执行其他线程，在sleep指定的时间过后，cpu才会回到这个线程上继续往下执行，如果当前线程进入同步锁，
sleep方法并不会释放锁，及时当前线程使用sleep方法让出cpu，但其他呗同步锁挡住了的线程也无法得到执行。
wait是住在一个已经进入了同步锁的建成内，让自己暂时让出同步锁，以便其他等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法调用wait方法的线程就会解除wait状态和程序可以再次得到锁后继续向下运行。对于wait的讲解看下面例子：
  1. package day9_10;

  3. public class MultiThread {

  5.         /**
  6.          * @param args
  7.          */
  8.         public static void main(String[] args) {
  9.                 new Thread(new Thread1()).start();
  10.                
  11.                 try {
  12.                         Thread.sleep(10);
  13.                 } catch (InterruptedException e) {
  14.                         e.printStackTrace();
  15.                 }
  16.                
  17.                 new Thread(new Thread2()).start();
  18.                
  19.                
  20.                
  21.                
  22.         }
  23.        
  24.         private static class Thread1 implements Runnable
  25.         {

  27.                 @Override
  28.                 public void run() {
  29.                         /*由于这里的Thread1和下面的Thread2内部的run方法用同一对象作为监视器
  30.                         我们这里不能用this，因为在thread2里面的his和这个Thread1的this不是同一个对象
  31.                         我们用MultiThread.class 这个字节码对象，当前虚拟机黎引用这个变量是，指向的都是同一个对象
  32.                         */
  33.                         synchronized (MultiThread.class) {
  34.                                 System.out.println("enter thread1");
  35.                                 System.out.println("thread1 is waiting");
  36.                                
  37.                                 /*
  38.                                  * 释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖
  39.                                  * 的代码范围，临沂中方式就是在synchronized关键子管辖的代码内部调用监视器对象的wait方法。这里使用wait方法释放锁
  40.                                  * */
  41.                                 try {
  42.                                         MultiThread.class.wait();
  43.                                 } catch (InterruptedException e) {
  44.                                         // TODO Auto-generated catch block
  45.                                         e.printStackTrace();
  46.                                 }
  47.                                 System.out.println("thread1 is going on...");
  48.                                 System.out.println("thread1 is being over!");
  49.                                
  50.                         }
  51.                        
  52.                 }
  53.                
  54.         }
  55.        
  56.         private static class Thread2 implements Runnable{

  58.                 @Override
  59.                 public void run() {
  60.                        
  61.                         synchronized (MultiThread.class) {
  62.                                 System.out.println("enter thread2...");
  63.                                 System.out.println("thread2 notify other thread can release wait status..");
  64.                         MultiThread.class.notify();
  65.                         System.out.println(" thread2 is sleeping ten millisecond");
  66.                         /*
  67.                          * 由于notify并不释放锁，
  68.                          * 及时thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，
  69.                          * 因为thread2没有释放锁，
  70.                          * 所以thread1无法得不到锁
  71.                          * */
  72.                        
  73.                         try {
  74.                                 Thread.sleep(10);
  75.                         } catch (InterruptedException e) {
  76.                                 // TODO Auto-generated catch block
  77.                                 e.printStackTrace();
  78.                         }
  79.                         System.out.println("thread2 is going on...");
  80.                         System.out.println("thread2 is being over!");
  81.                         }
  82.                 }
  83.                
  84.         }

  86. }
复制代码








欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2