wait方法可使本线程处于阻塞状态，让其他线程有机会有机会执行，如果其他的线程与之前的线程执行的设计同一块代码，那么它不也会执行wait（）吗，那么notify就没机会被执行了，而notify（）可以唤醒之前的线程，那么这样的话程序如何继续进行？

      sleep()是属于Thread类的方法，wait()、notify()和notifyAll()是根object的方法，它们所操控的是每个对象都会有的锁， 线程调用了wait()之后,会一直等下去，直到有别的线程调用了这个对象notify()或notifyAll()。
     你只能在synchronized方法或synchronized段里调用wait(),notify(),notifyAll()，否则程序运行时会抛出IllegalMonitorStateException。这个异常带着一个挺让人费解的“current thread not owner”消息。这个消息的意思是，如果线程调用对象的wait(),notify(),notifyAll(),必须先拥有这个对象的锁。调用notify()、notifyAll()方法后，被唤醒的唯一一个线程执行的第一条语句，是紧跟在wait()方法后面的语句。
     使用线程同步就行了，而且必须这么做[/color]

    。。。

所以 毕老师视频里面不是说了吗，notify() 是默认唤醒线程池中第一个等待的线程。  所以线程多的时候用notify()，如果遇到wait（）  就是使线程全部wait（），线程就都不动了。。
这时候就用到notifyAll()， 把全部线程都唤醒，  
为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
你学到老毕的 生产消费那 就懂了。。

JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。

Lock:替代了Synchronized
        lock
        unlock
        newCondition()

Condition：替代了Object wait notify notifyAll
        await();
        signal();
        signalAll();

就可以实现本方线程只唤醒对方操作。

1. class Resource{
   
2.                                 String name;
   
3.                                 String sex;
   
4. 
   
5.                                  boolean flag = true;
   
6.                                 public synchronized void put(String name,String sex){
   
7.                                         if(!flag){
   
8.                                                 try {
   
9.                                                         wait();//当标志位为false，线程wait这里其实是r.wait();
   
10.                                                 } catch (InterruptedException e1){}
    
11.                                         }
    
12.                                         this.name = name;
    
13.                                         this .sex = sex;
    
14.                                        
    
15.                                         flag = false;        //执行完后，将标志位状态改变。
    
16.                                         notify();                //并且唤醒一个线程这里其实是r.notify();
    
17.                                 }
    
18.                                
    
19.                                 public synchronized void get(){
    
20.                                         if(flag){
    
21.                                                 try {
    
22.                                                         wait();    //当标志位为true，线程wait。这里其实是r.wait();
    
23.                                                 } catch (InterruptedException e1){}
    
24.                                                 }
    
25.                                         System.out.println(name+"....."+sex);
    
26.                                        
    
27.                                         flag = true;//执行完后，将标志位状态改变。
    
28.                                         notify();//并且唤醒一个线程这里其实是r.notify();
    
29.                                         }
    
30.                                 }
    
31. 
    
32.                                 class Input implements Runnable{
    
33.                                         Resource r ;
    
34.                                         private int x=0;
    
35.                                         Input(Resource r){
    
36.                                                 this.r = r;
    
37.                                         }
    
38.                                         public  void run(){   //这里有一个线程任务
    
39.                                                 while(true){
    
40.                                                         if(x == 0){
    
41.                                                                 r.put("zhangsan","nan");//这里可以将同步代码封装
    
42.                                                         }else{
    
43.                                                                 r.put("lisi","nv");
    
44.                                                         }
    
45.                                                         x = (x+1)%2;
    
46.                                                 }
    
47.                                         }
    
48.                                 }
    
49. 
    
50.                                 class Output implements Runnable{
    
51.                                         Resource r ;
    
52.                                         Output(Resource r){
    
53.                                                 this.r = r;
    
54.                                         }
    
55.                                        
    
56.                                         public void run(){ //这里有一个线程任务
    
57.                                                 while(true){
    
58.                                                         r.get();        //这里可以将同步代码封装
    
59.                                                 }
    
60.                                         }
    
61.                                 }

复制代码

如果问题已解决，请及时修改分类，否则继续提问，谢谢合作！