rt，刚学完等待唤醒机制(day12-03)

写了个资源为单例模式的代码，能正常运行。但是对于其中的 if语句判断资源状态那里不是很明白。
毕老师视频中的是：初始化资源的标记为flase，并且对于Input和Output的判断语句分别是 if(资源对象.flag) 和 if(!(资源对象.flag)) ， 这两个判断语句怎么理解？

下面是我自己写的，if判断语句部分按照我自己写的和按照毕老师的写法都可以正常运行，但是不理解毕老师代码所表示的意思，求解释~

1. class Student//单例模式保证操作唯一对象(同一资源)
   
2. {
   
3.         String name;
   
4.         String sex;
   
5.         int grade;
   
6.         private Student(){}
   
7.         private static final Student s = new Student();
   
8.         public static Student getInstance()
   
9.         {
   
10.                 return s;
    
11.         }
    
12.         boolean flag = false;//定义一个状态标记
    
13. }
    
14. 
    
15. class Input implements Runnable//Input实现Runnable接口
    
16. {
    
17.         Student sin = Student.getInstance();//获得Student实例对象的引用
    
18.         public void run()//复写run方法
    
19.         {
    
20.                 int x = 0;//定义状态初始值
    
21.                 int a = 0;
    
22.                 while (a<30)//控制循环次数
    
23.                 {
    
24.                         synchronized(sin)//加锁，并为了验证单例，刻意在Input和Output中起不同的引用名=。=
    
25.                         {
    
26.                                 if (sin.flag==true)//判断资源状态<================这里毕老师写的是if(sin.flag)不明白为什么
    
27.                                         try
    
28.                                         {
    
29.                                                 sin.wait();//如果资源里面有东西就等待
    
30.                                         }
    
31.                                         catch (Exception e)
    
32.                                         {
    
33.                                         }
    
34.                                         if (x==0)
    
35.                                         {
    
36.                                                 sin.name = "李雷";
    
37.                                                 sin.sex = "male";
    
38.                                                 sin.grade = 1;
    
39.                                         }
    
40.                                         else
    
41.                                         {
    
42.                                                 sin.name = "韩梅梅";
    
43.                                                 sin.sex = "女女女女女女";
    
44.                                                 sin.grade = 2;
    
45.                                         }
    
46.                                         x = (x+1)%2;//用数值代表性别，控制交替执行
    
47.                                         System.out.println("传入::::"+sin.name+"......"+sin.sex+"......"+sin.grade+"年级......"+a);
    
48.                                         sin.flag = true;//执行后(input后)，将资源状态量改变为true
    
49.                                         sin.notify();//唤醒
    
50.                         }
    
51.                         a++;
    
52.                 }
    
53.         }
    
54. }
    
55. 
    
56. class Output implements Runnable//Output实现Runnable接口
    
57. {
    
58.         Student sou = Student.getInstance();//获得Student实例对象的引用，由于Student使用了单例模式，所以与Input中的sin指向的是同一个对象。
    
59.         public void run()//复写run方法
    
60.         {
    
61.                 int a = 0;
    
62.                 while (a<30)
    
63.                 {
    
64.                         synchronized(sou)//同步锁
    
65.                         {
    
66.                                 if (sou.flag==false)//判断资源状态，如果里面没有东西就等待<================这里毕老师写的是if(!(sou.flag))不明白为什么
    
67.                                         try
    
68.                                         {
    
69.                                                 sou.wait();
    
70.                                         }
    
71.                                         catch (Exception e)
    
72.                                         {
    
73.                                         }
    
74.                                 System.out.println("传出::::"+sou.name+"~~~~~~"+sou.sex+"~~~~~~"+sou.grade+"年级~~~~~~"+a);
    
75.                                 sou.flag = false;//输出后将资源状态切换为false
    
76.                                 sou.notify();//唤醒
    
77.                         }
    
78.                         a++;
    
79.                 }
    
80.         }
    
81. }
    
82. class  InputOutputDemo
    
83. {
    
84.         public static void main(String[] args)
    
85.         {
    
86.                 new Thread(new Input()).start();
    
87.                 new Thread(new Output()).start();
    
88.         }
    
89. }

复制代码

我学着的时候疑惑跟你一样，你看下我当时的帖子http://bbs.itheima.com/thread-51482-1-1.html

class Student//单例模式保证操作唯一对象(同一资源)
{
        String name;
        String sex;
        int grade;
        private Student(){}
        private static final Student s = new Student();
        public static Student getInstance()
        {
                return s;
        }
        boolean flag = false;//定义一个状态标记
}

class Input implements Runnable//Input实现Runnable接口
{
        Student sin = Student.getInstance();//获得Student实例对象的引用
        public void run()//复写run方法
        {
                int x = 0;//定义状态初始值
                int a = 0;
                while (a<30)//控制循环次数
                {
                        synchronized(sin)//加锁，并为了验证单例，刻意在Input和Output中起不同的引用名=。=
                        {
                                if (sin.flag==true)//判断资源状态<================这里毕老师写的是if(sin.flag)不明白为什么//很显然flag初始化为假，所以if判断为假就不执行wait()
                                        try
                                        {
                                                sin.wait();//如果资源里面有东西就等待
                                        }
                                        catch (Exception e)
                                        {
                                        }
                                        if (x==0)
                                        {
                                                sin.name = "李雷";
                                                sin.sex = "male";
                                                sin.grade = 1;
                                        }
                                        else
                                        {
                                                sin.name = "韩梅梅";
                                                sin.sex = "女女女女女女";
                                                sin.grade = 2;
                                        }
                                        x = (x+1)%2;//用数值代表性别，控制交替执行
                                        System.out.println("传入::::"+sin.name+"......"+sin.sex+"......"+sin.grade+"年级......"+a);
                                        sin.flag = true;//执行后(input后)，将资源状态量改变为true//然后线程运行到这flag被赋值为真，所以再运行到上面又要往资源里面存数据的时候上面的if（）里面就判断为真，         这时候if判断为真，那么就需要执行wait()
                                        sin.notify();//唤醒
                        }
                        a++;
                }
        }
}

class Output implements Runnable//Output实现Runnable接口
{
        Student sou = Student.getInstance();//获得Student实例对象的引用，由于Student使用了单例模式，所以与Input中的sin指向的是同一个对象。
        public void run()//复写run方法
        {
                int a = 0;
                while (a<30)
                {
                        synchronized(sou)//同步锁
                        {
                                if (sou.flag==false)//判断资源状态，如果里面没有东西就等待<================这里毕老师写的是if(!(sou.flag))不明白为什么//再然后线程运行到这flag值为真，所以！

                                                                                                                                                                                                                                            真  即为假，就不会运行wait()，
                                        try
                                        {
                                                sou.wait();
                                        }
                                        catch (Exception e)
                                        {
                                        }
                                System.out.println("传出::::"+sou.name+"~~~~~~"+sou.sex+"~~~~~~"+sou.grade+"年级~~~~~~"+a);
                                sou.flag = false;//输出后将资源状态切换为false//最后运行到这flag又被赋值为假，再运行到if(!sou.flag)   非假 就判断为真，那么此线程就需要wait()， 在wait()之前此线程唤醒了另外一个线程， 这时候flag值为假，  就重复这个顺序
                                sou.notify();//唤醒
                        }
                        a++;
                }
        }
}
class  InputOutputDemo
{
        public static void main(String[] args)
        {
                new Thread(new Input()).start();
                new Thread(new Output()).start();
        }
}

   if (sin.flag==true)//判断资源状态<================这里毕老师写的是if(sin.flag)不明白为什么

这句话意思是if(表达式) { 。。。} 。表达式为true的时候执行代码。

你感觉有必要 if(true  == true) 这样么。

赵乐 发表于 2013-5-30 19:59
我学着的时候疑惑跟你一样，你看下我当时的帖子http://bbs.itheima.com/thread-51482-1-1.html

class Stud ...

嗯看了下你之前的那个帖子，我也是对这个if判断的现实含义不太明白

我现在的理解是：
flag是资源库的标记，并被初始化为false（资源库里没东西，可以进，不可以出）
在Input中判断的时候如果flag==true 就 wait()    就是说资源库里有东西就等待
在Output中判断判断如果flag==flase 就 wait()    就是说资源库里没有东西就等待

如果按照毕老师的代码说就是：
flag是资源库的标记，并被初始化为false
在Input中判断标记if(flag)即if(false) 那么if语句不执行，就不wait 直接input

是这样么 ...

王瀛 发表于 2013-5-30 20:42
嗯看了下你之前的那个帖子，我也是对这个if判断的现实含义不太明白

我现在的理解是：

是的，我就是这样理解的
Output 中 同理了

赵乐 发表于 2013-5-30 20:46
是的，我就是这样理解的
Output 中 同理了

好的，感谢拉~{:2_32:}

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