问题1:运行结果出错,是什么意思?
问题2:此题能不能用类名.class锁?怎么用?
运行结果如下:
Exception in thread "Thread-0" Mike.....man
Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
        at java.lang.Object.notify(Native Method)
        at Input.run(ResourceDemo2.java:46)
        at java.lang.Thread.run(Thread.java:722)
java.lang.IllegalMonitorStateException
        at java.lang.Object.notify(Native Method)
        at Output.run(ResourceDemo2.java:73)
        at java.lang.Thread.run(Thread.java:722)

1. class  Resource
   
2. {
   
3.          String name;
   
4.          String sex;
   
5.          boolean flag=false;
   
6. }
   
7. 
   
8.       
   
9. 
   
10. class Input implements Runnable
    
11. {
    
12.         Resource r;
    
13.         Input(Resource r)
    
14.         {
    
15.                 this.r=r;
    
16.         }
    
17.         public void run()
    
18.         {
    
19.                 int x=0;
    
20.                 while(true)
    
21.                 {
    
22.                          synchronized(Resource.class)//能不能用Resource.class锁呢?
    
23.                         {
    
24.                                 if(r.flag)
    
25.                                 {
    
26.                                         //r.wait();
    
27.                                         try{r.wait();}catch(InterruptedException e){}
    
28.                                 }
    
29.                                        
    
30.                                 
    
31.                                 if(x==0)
    
32.                                 {
    
33.                                         r.name="Mike";
    
34.                                         r.sex="man";
    
35.                                 }
    
36.                                 else
    
37.                                 {
    
38.                                         r.name="大红";
    
39.                                         r.sex="女";
    
40.                                 }
    
41.                                 r.flag =true;
    
42.                                 r.notify();
    
43.                         }
    
44.                         x=(x+1)%2;
    
45.                 }
    
46.         }
    
47. }
    
48. 
    
49. class Output implements Runnable
    
50. {
    
51.         Resource r;
    
52.         Output(Resource r)
    
53.         {
    
54.                 this.r=r;
    
55.         }
    
56.         public void run()
    
57.         {
    
58.                 while(true)
    
59.                 {
    
60.                          synchronized(Resource.class)
    
61.                         {
    
62.                                 if (!r.flag)
    
63.                                 {
    
64.                                         //r.wait();
    
65.                                         try{r.wait();}catch(InterruptedException e){}
    
66.                                 }
    
67.                                 System.out.println(r.name+"....."+r.sex);
    
68.                                 r.flag=false;
    
69.                                 r.notify();
    
70.                         }
    
71.                 }
    
72.         }
    
73. }
    
74. 
    
75. class Demo2
    
76. {
    
77.         public static void main(String[] args)
    
78.         {
    
79.                 Resource r=new Resource();
    
80.                 Input in=new Input(r);
    
81.                 Output out=new Output(r);
    
82.                 Thread t1=new Thread(in);
    
83.                 Thread t2=new Thread(out);
    
84.                 t1.start();
    
85.                 t2.start();
    
86.         }
    
87. }

复制代码

package com.wenfengkeji.heima;
class  Resource
{
         String name;
         String sex;
         boolean flag=false;
}

class Input implements Runnable
{
        Resource r;
        Input(Resource r)
        {
                this.r=r;
        }
        public void run()
        {
                int x=0;
                while(true)
                {
                         synchronized(Resource.class)//能不能用Resource.class锁呢?
                        {
                                if(r.flag)
                                {
                                    try
                                    {
                                            Thread.currentThread().sleep(1000);
                                    }catch(InterruptedException e){
                                            throw new RuntimeException(e);
                                    }
                                }
                                if(x==0)
                                {
                                        r.name="Mike";
                                        r.sex="man";
                                }
                                else
                                {
                                        r.name="大红";
                                        r.sex="女";
                                }
                                r.flag =true;
                        }
                        x=(x+1)%2;
                }
        }
}

class Output implements Runnable
{
        Resource r;
        Output(Resource r)
        {
                this.r=r;
        }
        public void run()
        {
                while(true)
                {
                         synchronized(Resource.class)
                        {
                                if (!r.flag)
                                {
                                         try
                                     {
                                             Thread.currentThread().sleep(1000);
                                     }catch(InterruptedException e){
                                             throw new RuntimeException(e);
                                     }
                                }
                                System.out.println(r.name+"....."+r.sex);
                                r.flag=false;
                        }
                }
        }
}

class Demo2
{
        public static void main(String[] args)
        {
                Resource r=new Resource();
                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() 知道得到的是什么吗，是该类的字节码，类名不一样，该值也不一样，什么是字节码，你可以暂时将其理解为地址，具体看加强的视频
所以说你的第二个问题是：如果output的锁时Resource.class，你的第二题的答案就是yes

顽强探索中！

(1),问题主要在try{r.wait();}catch(InterruptedException e){}中的r.wait();当线程执行到r.wait()时,就会停在这里等待,在你用notify()唤醒它之前,线程不会去获取执行权,也就是说如果你不会唤醒它,它就会在那里不动的.所以最好是用sleep()方法,如sleep(1000);当线程睡了1秒之后,它自己会去获取执行权,在获取到执行权之后,就会执行下面的代码.
(2),可以用 类名.class 锁,就像你代码中那样用就可以了.
一个java文件(里面中只有一个类)通过编译后会产生一个 类名.class 文件,当运行这个程序时,JVM就会将class文件加载进内存中,在内存中就会产生一段二进制码对就这个class文件.        类名.class 代表的就是这段二进制码.     这个类的对象可以有多个,但是这个类在内存中所对就的二进制码是唯一的.     更具体的在学习反射时会接触到到,  也可以先看看java.lang包中的Class类.

刘明月 发表于 2012-9-28 00:19
首先做一下锁的总结：锁首先我会想到线程中用到锁，什么时候用呢，当我要确定线程需要同步时，

当时我做练 ...

更正一下
锁只能是对象，但是类名.class()这个字节码为什么可以作为锁呢，而且什么时候进行使用呢？
先说使用，当在静态方法中出现锁时，因为其中不能出现类的对象，所以通过字节码来识别，


所以楼主的第二个问题的答案应该是false

那运行时为什么会出现异常呢，还是我总结的那个：锁不相同，

如果把两个锁改成  r  就哦了