先看这个段代码，是老师讲生产者消费者的时候的

1.         public synchronized void set(String name){
   
2.                 while(flag){
   
3.                         try{wait();}catch(Exception e){}
   
4.                 }
   
5.                 this.name=name+"--"+count++;
   
6.                 System.out.println(Thread.currentThread().getName()+"....生产者..."+this.name);
   
7.                 flag=true;
   
8.                 this.notifyAll();
   
9.         }

复制代码

这个方法上有个  synchronized  意思就是 当有第二个线程是进不来的， 那里面的wait（） 还有什么用呢，让谁等待啊？

区别一下sleep()和wait()。
sleep()：让出CUP执行权，不释放同步锁；
wait()：不仅让出CUP执行权，并且释放同步锁。
当持有锁的线程进入等待状态，同步锁被释放，别的进程就能进来了。

在方法上的synchronized锁是的对象是本类对象即synchronized(this)，这里的生产者和消费者是两个不同的类，所以不是同一个锁，这里加锁是为了同步

1. /*
   
2. 多线程中最为常见的应用案例：
   
3. 生产者消费者问题。
   
4. 生产和消费同时执行，需要多线程。
   
5. 但是执行的任务却不相同，处理的资源确实相同的：线程间的通信。
   
6. 
   
7. 1，描述一下资源。
   
8. 2，描述生产者，因为具备着自己的任务。
   
9. 3，描述消费者，因为具备着自己的任务。
   
10. 
    
11. 
    
12. 问题1：数据错误：已经被生产很早期的商品，才被消费到。
    
13. 出现线程安全问题，加入了同步解决。使用同步函数。
    
14. 问题已解决：不会在消费到之前很早期的商品。
    
15. 
    
16. 问题2：发现了连续生产却没有消费，同时对同一个商品进行多次消费。
    
17. 希望的结果应该是生产一个商品，就被消费掉。生产下一个商品。
    
18. 搞清楚几个问题？
    
19. 生产者什么时候生产呢？消费者什么时候应该消费呢？
    
20. 当盘子中没有面包时，就生产，如果有了面包，就不要生产。
    
21. 当盘子中已有面包时，就消费，如果没有面包，就不要消费。
    
22. 
    
23. 生产者生产了商品后应该告诉消费者来消费。这时的生产者应该处于等待状态。
    
24. 消费者消费了商品后，应该告诉生产者，这时消费者处于等待状态。
    
25. 
    
26. 等待：wait();
    
27. 告诉：notify();//唤醒
    
28. 
    
29. 问题解决：实现生产一个消费一个。
    
30. 
    
31. =====================
    
32. 等待/唤醒机制。
    
33. wait(): 会让线程处于等待状态，其实就是将线程临时存储到了线程池中。
    
34. notify():会唤醒线程池中任意一个等待的线程。
    
35. notifyAll():会唤醒线程池中所有的等待线程。
    
36. 
    
37. 记住：这些方法必须使用在同步中，因为必须要标识wait，notify等方法所属的锁。
    
38. 同一个锁上的notify，只能唤醒该锁上的被wait的线程。
    
39. 
    
40. 为什么这些方法定义在Object类中呢？
    
41. 因为这些方法必须标识所属的锁，而锁可以是任意对象，任意对象可以调用的方法必然时Object类中的方法。
    
42. 
    
43. 举例：小朋友抓人游戏。
    
44. 
    
45. 
    
46. 
    
47. */
    
48. 
    
49. //1,描述资源。属性：商品名称和编号，  行为：对商品名称赋值，获取商品。
    
50. class Resource
    
51. {
    
52.         private String name;
    
53.         private int count = 1;
    
54. 
    
55.         //定义标记。
    
56.         private boolean flag = false;
    
57.        
    
58.         //1,提供设置的方法。
    
59.         public synchronized void set(String name)
    
60.         {
    
61. 
    
62.                 if(flag)
    
63.                         try{this.wait();}catch(InterruptedException e){}
    
64.                 //给成员变量赋值并加上编号。
    
65.                 this.name = name + count;
    
66.                 //编号自增。
    
67.                 count++;
    
68.                 //打印生产了哪个商品。
    
69.                 System.out.println(Thread.currentThread().getName()+"......生产者...."+this.name);
    
70. 
    
71.                 //将标记改为true。
    
72.                 flag = true;
    
73.                 //唤醒消费者。
    
74.                 this.notify();
    
75.         }
    
76.         public synchronized void out()
    
77.         {
    
78.                 if(!flag)
    
79.                         try{this.wait();}catch(InterruptedException e){}
    
80.                 System.out.println(Thread.currentThread().getName()+"....消费者...."+this.name);
    
81.                 //将标记该为false。
    
82.                 flag = false;
    
83.                 //唤醒生产者。
    
84.                 this.notify();
    
85.         }
    
86. }
    
87. 
    
88. //2,描述生产者。
    
89. class Producer implements Runnable
    
90. {
    
91.         private Resource r ;
    
92.         // 生产者一初始化就要有资源，需要将资源传递到构造函数中。
    
93.         Producer(Resource r)
    
94.         {
    
95.                 this.r = r;
    
96.         }
    
97.         public void run()
    
98.         {
    
99.                 while(true)
    
100.                 {
     
101.                         r.set("面包");
     
102.                 }
     
103.         }
     
104. }
     
105. 
     
106. //3,描述消费者。
     
107. class Consumer implements Runnable
     
108. {
     
109.         private Resource r ;
     
110.         // 消费者一初始化就要有资源，需要将资源传递到构造函数中。
     
111.         Consumer(Resource r)
     
112.         {
     
113.                 this.r = r;
     
114.         }
     
115.         public void run()
     
116.         {
     
117.                 while(true)
     
118.                 {
     
119.                         r.out();
     
120.                 }
     
121.         }
     
122. }
     
123. 
     
124. 
     
125. 
     
126. 
     
127. class ThreadDemo9
     
128. {
     
129.         public static void main(String[] args)
     
130.         {
     
131.                 //1,创建资源对象。
     
132.                 Resource r = new Resource();
     
133. 
     
134.                 //2,创建线程任务。
     
135.                 Producer pro = new Producer(r);
     
136.                 Consumer con = new Consumer(r);
     
137. 
     
138.                 //3,创建线程。
     
139.                 Thread t1 = new Thread(pro);
     
140.                 Thread t2 = new Thread(con);
     
141. 
     
142.                 t1.start();
     
143.                 t2.start();
     
144.         }
     
145. }
     

复制代码

你没看全啊，这是毕姥爷讲课的笔记，你看下，wait()是让当前这个线程进入等待

首先你要明白wait()方法的作用：
wait()方法，线程会停止运行，不会自动启动，要等其它线程唤醒。然后该线程不但交出CPU执行权，并且还释放锁，也就是说该线程不再持有锁，其它线程可以进来。
另外你要与sleep()方法区别开，别混淆了。
sleep()方法，线程会暂时停止运行，并交出CPU执行权，等睡眠时间到了线程会继续启动，但是这个过程并不释放锁，也就是说该线程仍然持有锁，其它线程进不来。