wait 和 notify 同步小问题，帮我修改下小代码。马上结贴。

Question

class PO
{
public static void main(String args[])
{
ThreadDemo th = new ThreadDemo();
th.start();
for(int i=0;;i++)
{
System.out.println("main.i="+i);
wait();
notify();
}

}
}
class ThreadDemo extends Thread
{
public void run()
{
for(int i= 0;;i++)
{
System.out.println("ThreadDemo.i="+i);
wait();
notify();
}
}
}

Answer 1

没有try catch；需要定义Po的实例；

Answer 2

class PO
{
    public static void main(String args[])
    {
        ThreadDemo th = new ThreadDemo();
        th.start();
        PO p = new PO();
        for(int i=0;;i++)
        {
            System.out.println("main.i="+i);
            try{
             p.wait();
                p.notify();
            }
            catch(Exception e){
            
            }        }
        
    }
}
class ThreadDemo extends Thread
{
    public void run()
    {
        for(int i= 0;;i++)
        {
            System.out.println("ThreadDemo.i="+i);
            try{
             wait();
             notify();
             }
            catch(Exception e)
            {}
        }
    }
}

Answer 3

这里我非常不明白就是 wait 怎么传给notify的
假如还有第三，第四个线程，它就不知道唤醒谁了。

Answer 4

...
1.wait，notify,notifyAll方法必须放在synchronized内。
2.wait需要异常处理
3.wait,notity,notifyAll是非静态方法，不能直接用在main里面

Answer 5

class P0
{
    public static void main(String args[])
    {
        ThreadDemo th = new ThreadDemo();
        th.start();

        for(int i=0;;i++)
        {
            System.out.println("main.i="+i);
            try {
new P0().wait();
                                new p0().notify();
} catch (InterruptedException e) {

e.printStackTrace();
}
            new P0().notify();
        }
        
    }
}
class ThreadDemo extends Thread
{
    public void run()
    {
        for(int i= 0;;i++)
        {
            System.out.println("ThreadDemo.i="+i);
            try {
wait();
} catch (InterruptedException e) {

e.printStackTrace();
}
            notify();
        }
    }
}
运行起好像有些问题，我也不懂这个干嘛的？？？

Answer 6

这个帅哥说得很好. notify 是唤醒队列中的一个进程,至于具体是哪一个进程是没有办法知道的!.比如同时wait()有10个进程(当然我们这里假设这10个进程都是wait的同一个对象的锁哈,要不是同一个对象当然notify notifyAll也无效哈) 执行notify后有一个会唤醒,但是不能确定是notify这10个中的哪一个了.
notifyAll()是把所有这wait()的10个进程都唤醒!  这里只是从wait()状态出来到就绪状态哈,至于执行,跟这个又没有关系了. 

Answer 7

是通过对象来的.wait 和notify 是对象的方法. class PO
{


    public static void main(String args[]) throws Exception
    {
        ThreadDemo th = new ThreadDemo();
        ThreadDemo th2 = new ThreadDemo();
        th2.start();
        th.start();
        Thread.sleep(100);
        synchronized(th2){
        for(int i=0;i< 10;i++)
        {
            System.out.println("main.i="+i);
            th2.notify();//这里只是notify的th2对象的wait状态.
        }
        }
    }
}
class ThreadDemo extends Thread
{
static int idCount = 0;
int id;
ThreadDemo(){
idCount++;
id = idCount;

}
    public  void   run()
    {synchronized(this){
//        for(int i= 0;i<1;i++)
//        {
     System.out.println("th.id " + this.id);
            try {
this.wait();
System.out.println("th.id " + this.id);

} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//            notify();这句话没有意义吧.前面都wait了,这里notify执行不到这来啊.
// 要是前面没有wait那你这个notify谁啊
        }
    }
//    }
}通过输出看到它并没有唤醒 把两个thread都唤醒. 
th.id 2
th.id 1
main.i=0
main.i=1
main.i=2
main.i=3
main.i=4
main.i=5
main.i=6
main.i=7
main.i=8
main.i=9
th.id 2

Answer 8

想要全部唤醒用notifyAll, notify 唤醒取决于虚拟机的调度机制，无法通过程序操控

Answer 9

选择notify的话,因为要唤醒的线程比较少,程序处理速度当然比notifyAll高出一些.但选择notify的时候,若这部分处理得不好,可能会有程序挂掉的危险性。一般来说，选择notifyAll所写出来的程序代码会比选择notify可靠。除非你能确定程序员对程序代码的意义和能力限度一清二楚，否则选择notifyAll应该更稳妥一些。

Answer 10

我只看到了没try catch 接着9楼说 notifyAll 以后，假如有10线程，并不是把锁给哪个线程，
不确定的，
而是让他们去竞争。

Answer 11

顶!补充一下, wait()不是在notify()后马上就响应,是在含notify的方法退出sychronized临界区后才有可能响应的.之所以是有可能是因为可能还会有其他线程跟它抢. 所以有些情况是需要while(!条件满足) wait();建议看一下这里的内容:http://blog.csdn.net/Iangao/archive/2008/10/09/3041265.aspx

Answer 12

这个贴已经有点时间了。下午一定要结贴了。但说真的对于notify 和 wait 我真不知道怎么下手。