对于sleep()方法，首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

获取对象锁进入运行状态。

什么意思呢？举个来列子说明：

1. package heima.day04;
   
2. public class TestD {
   
3. 
   
4.         public static void main(String[] args) {
   
5.                 new Thread(new Thread1()).start();
   
6.                 try {
   
7.                         Thread.sleep(5000);
   
8.                 } catch (Exception e) {
   
9.                         e.printStackTrace();
   
10.                 }
    
11.                 new Thread(new Thread2()).start();
    
12.         }
    
13.         private static class Thread1 implements Runnable {
    
14.                 public void run() {
    
15.                         synchronized (TestD.class) {
    
16.                                 System.out.println("enter thread1...");
    
17.                                 System.out.println("thread1 is waiting...");
    
18.                                 try {
    
19.                                         //调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
    
20.                                         TestD.class.wait();
    
21.                                 } catch (Exception e) {
    
22.                                         e.printStackTrace();
    
23.                                 }
    
24.                                 System.out.println("thread1 is going on ....");
    
25.                                 System.out.println("thread1 is over!!!");
    
26.                         }
    
27.                 }
    
28.         }
    
29.         private static class Thread2 implements Runnable {
    
30. 
    
31.                 public void run() {
    
32.                         synchronized (TestD.class) {
    
33.                                 System.out.println("enter thread2....");
    
34.                                 System.out.println("thread2 is sleep....");
    
35.                                 //只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
    
36.                                 TestD.class.notify();
    
37.                                 //==================
    
38.                                 //区别
    
39.                                 //如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
    
40.                                 //方法，则线程永远处于挂起状态。
    
41.                                 try {
    
42.                                         //sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，
    
43.                                         //但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
    
44.                                         //在调用sleep()方法的过程中，线程不会释放对象锁。
    
45.                                         Thread.sleep(5000);
    
46.                                 } catch (Exception e) {
    
47.                                         e.printStackTrace();
    
48.                                 }
    
49.                                 System.out.println("thread2 is going on....");
    
50.                                 System.out.println("thread2 is over!!!");
    
51.                         }
    
52.                 }
    
53.         }
    
54. }
    
55. /*
    
56. * 运行结果
    
57. * enter thread1...
    
58.    thread1 is waiting...
    
59.    enter thread2....
    
60.    thread2 is sleep....
    
61.    thread2 is going on....
    
62.    thread2 is over!!!
    
63.    thread1 is going on ....
    
64.    thread1 is over!!!
    
65. */

复制代码

如果注释掉代码

1. Thread.sleep(5000);

复制代码

运行效果：

1. enter thread1...
   
2. thread1 is waiting...
   
3. enter thread2....
   
4. thread2 is sleep....
   
5. thread2 is going on....
   
6. thread2 is over!!!
   
7. thread1 is going on ....
   
8. thread1 is over!!!
   

复制代码

对于sleep()方法，首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。

在调用sleep()方法的过程中，线程不会释放对象锁。

而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备

获取对象锁进入运行状态。

什么意思呢？举个来列子说明：

1. package heima.day04;
   
2. public class TestD {
   
3. 
   
4.         public static void main(String[] args) {
   
5.                 new Thread(new Thread1()).start();
   
6.                 try {
   
7.                         Thread.sleep(5000);
   
8.                 } catch (Exception e) {
   
9.                         e.printStackTrace();
   
10.                 }
    
11.                 new Thread(new Thread2()).start();
    
12.         }
    
13.         private static class Thread1 implements Runnable {
    
14.                 public void run() {
    
15.                         synchronized (TestD.class) {
    
16.                                 System.out.println("enter thread1...");
    
17.                                 System.out.println("thread1 is waiting...");
    
18.                                 try {
    
19.                                         //调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池
    
20.                                         TestD.class.wait();
    
21.                                 } catch (Exception e) {
    
22.                                         e.printStackTrace();
    
23.                                 }
    
24.                                 System.out.println("thread1 is going on ....");
    
25.                                 System.out.println("thread1 is over!!!");
    
26.                         }
    
27.                 }
    
28.         }
    
29.         private static class Thread2 implements Runnable {
    
30. 
    
31.                 public void run() {
    
32.                         synchronized (TestD.class) {
    
33.                                 System.out.println("enter thread2....");
    
34.                                 System.out.println("thread2 is sleep....");
    
35.                                 //只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
    
36.                                 TestD.class.notify();
    
37.                                 //==================
    
38.                                 //区别
    
39.                                 //如果我们把代码：TestD.class.notify();给注释掉，即TestD.class调用了wait()方法，但是没有调用notify()
    
40.                                 //方法，则线程永远处于挂起状态。
    
41.                                 try {
    
42.                                         //sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，
    
43.                                         //但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态。
    
44.                                         //在调用sleep()方法的过程中，线程不会释放对象锁。
    
45.                                         Thread.sleep(5000);
    
46.                                 } catch (Exception e) {
    
47.                                         e.printStackTrace();
    
48.                                 }
    
49.                                 System.out.println("thread2 is going on....");
    
50.                                 System.out.println("thread2 is over!!!");
    
51.                         }
    
52.                 }
    
53.         }
    
54. }
    
55. /*
    
56. * 运行结果
    
57. * enter thread1...
    
58.    thread1 is waiting...
    
59.    enter thread2....
    
60.    thread2 is sleep....
    
61.    thread2 is going on....
    
62.    thread2 is over!!!
    
63.    thread1 is going on ....
    
64.    thread1 is over!!!
    
65. */

复制代码

如果注释掉代码

1. Thread.sleep(5000);

复制代码

运行效果：

1. enter thread1...
   
2. thread1 is waiting...
   
3. enter thread2....
   
4. thread2 is sleep....
   
5. thread2 is going on....
   
6. thread2 is over!!!
   
7. thread1 is going on ....
   
8. thread1 is over!!!
   

复制代码