class Res
{
        String name;
        String sex;
        boolean flag = false;
}

class Input implements Runnable
{
        private Res r ;
        Input(Res r)
        {
                this.r = r;
        }
        public void run()
        {
                int x = 0;
                while(true)
                {
                        synchronized(r)
                        {

                                if(r.flag)
                                        try{r.wait();}catch(Exception e){}//当t1线程进入到这里睡眠时，已经进入了synchronized的同步代码块，而且与t2线程用的是同一个“锁”
                                                                                     //可是为什么t1此时还在同步代码块里面，唤醒了t2后，t2还能进入同个“锁”的同步代码块？                              
                                       if(x==0)
                                {
                                        r.name="mike";
                                        r.sex="man";
                                }
                                else
                                {
                                        r.name="丽丽";
                                        r.sex = "女女女女女";
                                }
                                x = (x+1)%2;
                                r.flag = true;
                                r.notify();
                        }
                }
        }
}

class Output implements Runnable
{
        private Res r ;
        
        Output(Res r)
        {
                this.r = r;
        }
        public void run()
        {
                while(true)
                {
                        synchronized(r)
                        {
                                if(!r.flag)
                                        try{r.wait();}catch(Exception e){}
                                System.out.println(r.name+"...."+r.sex);//当t1睡眠，唤醒t2，t1还在代码块里面，t2也能进入这个代码块里面执行语句。                                             
                               r.flag = false;
                                r.notify();
                        }
                }
        }
}


class  InputOutputDemo
{
        public static void main(String[] args)
        {
                Res r = new Res();

                Input in = new Input(r);
                Output out = new Output(r);

                Thread t1 = new Thread(in);
                Thread t2 = new Thread(out);

                t1.start();
                t2.start();
        }
}

class Res
{
         String name;
         String sex;
         boolean flag = false;
}

class Input implements Runnable
{
         private Res r ;
         Input(Res r)
         {
                 this.r = r;
         }
         public void run()
         {
                 int x = 0;
                 while(true)
                 {
                         synchronized(r)
                         {

                                if(r.flag)
                                         try{r.wait();}catch(Exception e){} //这个应该是多线程的等待唤醒机制。t1存储数据时先判断flag的值，flag为false时，
                                                                        //则往Res里面添加数据，然后将flag的值改为true，下次存储时，判断flag的值为true，则t1
                                                                        //就会等待，在等待之前唤醒t2.
                                 if(x==0)
                                 {
                                         r.name="mike";
                                         r.sex="man";
                                 }
                                 else
                                 {
                                         r.name="丽丽";
                                         r.sex = "女女女女女";
                                 }
                                 x = (x+1)%2;
                                 r.flag = true;
                                 r.notify();
                         }
                 }
         }
}

class Output implements Runnable
{
         private Res r ;
         
        Output(Res r)
         {
                 this.r = r;
         }
         public void run()
         {
                 while(true)
                 {
                         synchronized(r)
                         {
                                 if(!r.flag)
                                         try{r.wait();}catch(Exception e){}
                                 System.out.println(r.name+"...."+r.sex);//t2读取数据时先判断flag的值，flag为true时，
                                                                        //则从Res里面读取数据，然后将flag的值改为false，下次读取时，判断flag的值为false，则t2
                                                                        //就会等待，在等待之前唤醒t1.  因为t1和t2时两个不同的线程它们之间彼此相互独立，但是却操作的是同一个资源。
                                                                        //所以它们就要使用同一把锁，它们之间的运行互不影响只不过都是通过判断flag的值来决定是应该读取还是应该添加                             
                                r.flag = false;
                                 r.notify();
                         }
                 }
         }
}


class  InputOutputDemo
{
         public static void main(String[] args)
        {
                 Res r = new Res();

                Input in = new Input(r);
                 Output out = new Output(r);

                Thread t1 = new Thread(in);
                 Thread t2 = new Thread(out);

                t1.start();
                 t2.start();
         }
}

当线程调用wait()的时候会释放资源，同时会释放锁；资源锁是被释放了的，所以其他的线程就进来了

当你在调用wait的时候，当前线程会自动释放其占有的对象锁，同时不会去申请对象锁，该线程同时也调用了notify方法，将其他线程唤醒，其他线程将获得对象锁的使用权，将执行自己线程的同步代码块部分。这就是等待唤醒机制的原理。最主要就是理解wait和notify两个方法具体都做了什么：简单的说就是wait方法会使当前线程释放对象锁，而notify方法会使之前等待状态的线程获取对象锁。

刘煜 发表于 2012-7-16 02:22
当你在调用wait的时候，当前线程会自动释放其占有的对象锁，同时不会去申请对象锁，该线程同时也调用了noti ...

那当有两个线程在同步代码块里“睡着了”,也就是wait()了。
第三个线程如main 万一开启了 notifyAll，那岂不是上两个线程同时在一个同步代码块里了？那怎么办？

陆鹏 发表于 2012-7-16 12:00
那当有两个线程在同步代码块里“睡着了”,也就是wait()了。
第三个线程如main 万一开启了 notifyAll，那 ...

哥们
   调用notifyAll通知所有线程继续执行，只能有一个线程在执行，其余的线程在等待(因为在所有线程被唤醒的时候在synchornized块中)。这时的等待和调用notifyAll前的等待是不一样的。
notifyAll前：在对象上休息区内休息
notifyAll后：在排队等待获得对象锁。



notify()与notifyAll()的区别    notify和notifyAll都是把某个对象上休息区内的线程唤醒,notify只能唤醒一个,但究竟是哪一个不能确定,而notifyAll则唤醒这个对象上的休息室中所有的线程.
一般有为了安全性,我们在绝对多数时候应该使用notifiAll(),除非你明确知道只唤醒其中的一个线程.

明白了，谢谢