A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 陆鹏 于 2012-7-16 16:02 编辑

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();
        }
}

评分

参与人数 1技术分 +1 收起 理由
韦念欣 + 1 赞一个!

查看全部评分

6 个回复

倒序浏览
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 14:29 编辑
陆鹏 发表于 2012-7-16 12:00
那当有两个线程在同步代码块里“睡着了”,也就是wait()了。
第三个线程如main 万一开启了 notifyAll,那 ...


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



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

评分

参与人数 1技术分 +1 收起 理由
刘笑 + 1 赞一个!

查看全部评分

回复 使用道具 举报
陆鹏 中级黑马 2012-7-16 15:05:47
7#
明白了,谢谢
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马