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;
   
2. 
   
3. public class MultiThread {
   
4. 
   
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.         {
    
26. 
    
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{
    
57. 
    
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.         }
    
85. 
    
86. }
    

复制代码

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;
   
2. 
   
3. public class MultiThread {
   
4. 
   
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.         {
    
26. 
    
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{
    
57. 
    
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.         }
    
85. 
    
86. }
    

复制代码