1. class Res
   
2. {
   
3.         String name;
   
4.         String sex;
   
5. }
   
6. class Input implements Runnable
   
7. {
   
8.         private Res r;
   
9.         Input(Res r)
   
10.         {
    
11.                 this.r=r;
    
12.         }
    
13.         public void run()
    
14.         {
    
15.                 boolean flag=true;
    
16.                 while(true)
    
17.                 {
    
18.                         synchronized(r){
    
19.                                 if(flag)
    
20.                                 {
    
21.                                         r.name="Mike";
    
22.                                         r.sex="man";
    
23.                                         flag=false;
    
24.                                 }
    
25.                                 else
    
26.                                 {
    
27.                                         r.name="丽丽";
    
28.                                         r.sex="女女女女女";
    
29.                                         flag=true;
    
30.                                 }
    
31.                         }
    
32.                 }
    
33.         }
    
34. }
    
35. class Output implements Runnable
    
36. {
    
37.         private Res r;
    
38.         Output(Res r)
    
39.         {
    
40.                 this.r=r;
    
41.         }
    
42.         public void run()
    
43.         {
    
44.                 while(true)
    
45.                 {
    
46.                         synchronized(r)
    
47.                         {
    
48.                                 System.out.println(r.name+"..."+r.sex);
    
49.                         }
    
50.                 }
    
51.         }
    
52. }
    
53. class  InputOutputDemo
    
54. {
    
55.         public static void main(String[] args)
    
56.         {
    
57.                 Res r=new Res();
    
58. 
    
59.                 Input in=new Input(r);
    
60.                 Output out=new Output(r);
    
61. 
    
62.                 Thread t1=new Thread(in);
    
63.                 Thread t2=new Thread(out);
    
64. 
    
65.                 t1.start();
    
66.                 t2.start();
    
67. 
    
68.                 //System.out.println("Hello World!");
    
69.         }
    
70. }
    

复制代码

在Input和Output方法中为了同步其操作的是同一个资源，在其类中添加了Res类对象作为其成员，可是在现实中我们在类似的Input和Output方法操作中并不知道我们要操作的对象类型或者是什么样的对象，除了用
private Res r;
        Output(Res r)
        {
                this.r=r;
        }
这样的方式来同步两个线程操作的资源呢？有没有别的方法！

有，1.5jdk出了一把新锁，可见操作，Api文档查阅Lock包里，操作超级简单，步骤就是上锁，解锁，就这两个Lock  and unLock，

我也是个新手，按我的理解先说下楼上的答案，他的2个线程分别操作的是Res类中的2个属性的赋值和输出。这2个线程没有冲突的地方，也就没必要使用同步代码块。也就没有楼上所说的锁的使用了。用了反而降低效率。

我没太看明白你这个程序的意图，如果你只是想在对Res进行赋值的同时也输出。你可以定义一个类，类中有这2个方法（你的Input和Output是2个类实现了Runnable接口，而不是2个方法）。然后当你需要使用这2个方法的时候，只要将你需要操作的资源定义成一个类继承这个类，就可以使用这2个方法了。

你为谁归来 发表于 2014-4-11 17:42
我没太看明白你这个程序的意图，如果你只是想在对Res进行赋值的同时也输出。你可以定义一个类，类中有这2个 ...

这个可以！我看后面的视频才看到！