一、源程序：

1. package xiancheng;
   
2. 
   
3. public class YouhuaThreadCommunity
   
4. {
   
5.         /*
   
6.          * 线程通讯：其实就是多个线程操作同一块资源，但是操作的行为不同
   
7.          *  需求：一个人往箱子里装东西，一个人往箱子取东西。
   
8.          *  东西：Res{name,sex;}
   
9.          * 输入类：Input{Res,run()}
   
10.          * 输出类： Oupt{Res,run()}
    
11.          */
    
12.         public static void main(String[] args)
    
13.         {
    
14.                 Res1 r = new Res1();
    
15.                 Input1 in = new Input1(r);
    
16.                 Output1 out = new Output1(r);
    
17.                 new Thread(in).start();
    
18.                 new Thread(out).start();
    
19.                 Input1 in1 = new Input1(r);
    
20.                 Output1 out1 = new Output1(r);
    
21.                 new Thread(in1).start();
    
22.                 new Thread(out1).start();
    
23.         }
    
24. }
    
25. 
    
26. /*
    
27. * 实现资源输出
    
28. */
    
29. class Input1 implements Runnable
    
30. {
    
31.         Res1 res;
    
32. 
    
33.         /**
    
34.          * 初始化资源
    
35.          *
    
36.          * @param r
    
37.          */
    
38.         public Input1(Res1 r)
    
39.         {
    
40.                 this.res = r;
    
41.         }
    
42. 
    
43.         /*
    
44.          * 复写run()方法，生产资源
    
45.          */
    
46.         @Override
    
47.         public void run()
    
48.         {
    
49.                 int x = 0;
    
50.                 while (true)
    
51.                 {
    
52.                         res.setName("coke", "man");
    
53.                         res.setName("笑话", "女");
    
54.                 }
    
55. 
    
56.         }
    
57. 
    
58. }
    
59. 
    
60. class Output1 implements Runnable
    
61. {
    
62. 
    
63.         Res1 res;
    
64. 
    
65.         /*
    
66.          * 初始化输出资源
    
67.          */
    
68.         public Output1(Res1 r)
    
69.         {
    
70.                 this.res = r;
    
71.         }
    
72. 
    
73.         /*
    
74.          * 复写run()方法，消费资源
    
75.          */
    
76.         @Override
    
77.         public void run()
    
78.         {
    
79. 
    
80.                 while (true)
    
81.                 {
    
82.                         res.show();
    
83.                 }
    
84. 
    
85.         }
    
86. }
    
87. 
    
88. class Res1
    
89. {
    
90.         private String name;
    
91.         private String sex;
    
92.         private boolean flag = false;
    
93. 
    
94.         /**
    
95.          * 设置资源的name与sex的值。
    
96.          *  模拟生产资源
    
97.          *
    
98.          * @param name
    
99.          * @param sex
    
100.          */
     
101.         public synchronized void setName(String name, String sex)
     
102.         {
     
103.                 while (flag)
     
104.                         try
     
105.                         {
     
106.                                 this.wait();//冻结
     
107.                         } catch (InterruptedException e)
     
108.                         {
     
109.                                 e.printStackTrace();
     
110.                         }
     
111.                 this.name = name;
     
112.                 this.sex = sex;
     
113.                 flag = true;
     
114.                 this.notifyAll();//唤醒全部冻结线程
     
115.         }
     
116. 
     
117.         /**
     
118.          * 模拟消费资源
     
119.          */
     
120.         public synchronized void show()
     
121.         {
     
122.                 while (!flag)
     
123.                         try
     
124.                         {
     
125.                                 this.wait();//冻结
     
126.                         } catch (InterruptedException e)
     
127.                         {
     
128.                                 e.printStackTrace();
     
129.                         }
     
130.                 System.out.println(name + "---消费---" + sex);
     
131.                 flag = false;
     
132.                 this.notifyAll();//唤醒全部冻结线程
     
133. 
     
134.         }
     
135. 
     
136. }
     

复制代码

二、问题如下：
为什么第一句输出“笑话---消费---女”不是成对的出现？
笑话---消费---女
coke---消费---man
coke---消费---man
笑话---消费---女
笑话---消费---女
coke---消费---man
coke---消费---man
笑话---消费---女
笑话---消费---女

main函数里面这样写：

1.                 Res1 r = new Res1();
   
2.                 Input1 in = new Input1(r);
   
3.                 Output1 out = new Output1(r);
   
4.                 new Thread(in).start();
   
5.                 new Thread(out).start();
   
6.                
   
7.                 Res1 r1 = new Res1();
   
8.                 Input1 in1 = new Input1(r1);
   
9.                 Output1 out1 = new Output1(r1);
   
10.                 new Thread(in1).start();
    
11.                 new Thread(out1).start();

复制代码

两个不同的消费关系应该使用两个不同的资源

1. package xiancheng;
   
2. 
   
3. public class YouhuaThreadCommunity
   
4. {
   
5.         /*
   
6.          * 线程通讯：其实就是多个线程操作同一块资源，但是操作的行为不同
   
7.          *  需求：一个人往箱子里装东西，一个人往箱子取东西。
   
8.          *  东西：Res{name,sex;}
   
9.          * 输入类：Input{Res,run()}
   
10.          * 输出类： Oupt{Res,run()}
    
11.          */此处Output

复制代码

改完后运行下没事了

肖川 发表于 2013-4-22 23:47
main函数里面这样写：两个不同的消费关系应该使用两个不同的资源

本来就是要解决共享资源的问题。你这样分开没意思了！

wodeairenw 发表于 2013-4-23 01:35
你建立了两个输入线程，两个取出线程，你可以定义一下线程的名称获取String name =Thread.currentThread(). ...

代码就是从老师那里看的，老师那边运行没事，怎么我的就是第一句没有匹配的？

潘廖明 发表于 2013-4-23 01:42
本来就是要解决共享资源的问题。你这样分开没意思了！

你多运行几次就会得到不同的结果。可能与你的cpu运行速度有关，你一个生产者生产出来后还没来得及消费就开始了第二个生产.....