1. /*多线程_等待唤醒机制*/
   
2. 
   
3. /**
   
4. *需求：创建两个线程，一个进行存储信息，一个进行打印信息。
   
5. *目的：程序输入一个"mike man"打印一个"mike man"
   
6. *           输入一个"莉莉 女女女女女"打印一个"莉莉 女女女女女"
   
7. *步骤：创建一个共享资源类RescourceWaitNotifyDemo
   
8. *                创建输入线程类InputWaitNotifyDemo
   
9. *                创建打印线程类OutputWaitNotifyDemo
   
10. *                由主函数创建线程，并执行。
    
11. *问题：
    
12. *                为什么会有线程安全问题？
    
13. *                怎么解决？
    
14. */
    
15. 
    
16. /*线程共享资源类，信息类*/
    
17. class ResourceWaitNotifyDemo //
    
18. {
    
19.         private String name;
    
20.         private String sex;
    
21.         private boolean flag=false;
    
22. 
    
23. 
    
24.         public synchronized void setInfo(String name,String sex)//信息输入函数
    
25.         {
    
26.                 if(flag)
    
27.                 /*如果flag值为false，则共享资源中没有信息，进行赋值
    
28.                   如果为true,则共享资源中有信息没有打印，不进行赋值，进行wait操作
    
29.                 */        
    
30.                 {
    
31.                         try
    
32.                         {
    
33.                                 this.wait();
    
34.                         }
    
35.                         catch (Exception e)
    
36.                         {
    
37.                         }
    
38.                 }
    
39.                 else
    
40.                 {
    
41.                         this.name = name;
    
42.                         this.sex = sex;                        
    
43.                 }        
    
44.                 flag=true;         //改变开关，让输入程序不能再次进行赋值，同时可以让打印程序启动
    
45.                 this.notify();//唤醒输出线程
    
46.         }
    
47. 
    
48.         public synchronized void OutInfo()//信息输出函数
    
49.         {
    
50.                 if (!flag)//如果flag值为ture，则共享资源中有信息，进行打印，否则等待
    
51.                 {
    
52.                         try
    
53.                         {
    
54.                                 this.wait();
    
55.                         }
    
56.                         catch (Exception e)
    
57.                         {
    
58.                         }
    
59.                 }
    
60.                 else
    
61.                 {
    
62.                         System.out.println(name+"......"+sex);                        
    
63.                 }               
    
64.                 flag=false;        //改变开关，让输入程序可以进行赋值，同时让自己不能在打印
    
65.                 this.notify();//唤醒输入线程
    
66.         }
    
67. }
    
68. 
    
69. /*输入线程*/
    
70. class InputWaitNotifyDemo implements Runnable
    
71. {
    
72.         private ResourceWaitNotifyDemo r;        //创建共享类引用
    
73. 
    
74.         InputWaitNotifyDemo(ResourceWaitNotifyDemo r)
    
75.         {
    
76.                 this.r = r;        //接收共享类对象
    
77.         }
    
78. 
    
79.         public void run()
    
80.         {
    
81.                 int x=0;
    
82.                 while(true)
    
83.                 {        
    
84.                         if (x==0)
    
85.                         {
    
86.                                 r.setInfo("mike","man");
    
87.                         }
    
88.                         else
    
89.                         {
    
90.                                 r.setInfo("莉莉","女女女女女");
    
91.                         }
    
92.                         x=(x+1)%2;                                                
    
93.                 }
    
94.         }
    
95. 
    
96. }
    
97. 
    
98. /*输出线程*/
    
99. class OutputWaitNotifyDemo implements Runnable
    
100. {
     
101.         private ResourceWaitNotifyDemo r;
     
102. 
     
103.         OutputWaitNotifyDemo(ResourceWaitNotifyDemo r)
     
104.         {
     
105.                 this.r = r;        //和输入线程操作同一个共享类对象
     
106.         }
     
107. 
     
108.         public void run()
     
109.         {
     
110.                 while (true)
     
111.                 {
     
112.                         r.OutInfo();        
     
113.                 }
     
114.         }
     
115. }
     
116. 
     
117. /*主函数*/
     
118. class ThreadWaitNotifyTest
     
119. {
     
120.         public static void main(String[] args)
     
121.         {
     
122.                 ResourceWaitNotifyDemo res = new ResourceWaitNotifyDemo();
     
123. /*
     
124.                 InputWaitNotifyDemo i = new InputWaitNotifyDemo(res);
     
125.                 OutputWaitNotifyDemo o = new OutputWaitNotifyDemo(res);
     
126. 
     
127.                 Thread t1 = new Thread(i);
     
128.                 Thread t2 = new Thread(o);
     
129. 
     
130.                 t1.start();
     
131.                 t2.start();
     
132. */
     
133.                 new Thread(new InputWaitNotifyDemo(res)).start();        //创建输入线程
     
134.                 new Thread(new OutputWaitNotifyDemo(res)).start();        //创建打印线程
     
135.         }
     
136. }

复制代码

潘天功 发表于 2012-11-24 21:11
1、为什么会有线程安全问题？
   原因：（1）多线程访问出现延迟（由于共享数据导致）；
         （2）线 ...

这代码有安全问题。我是让你们帮我解决这代码的问题，不是让你们帮我背定理啊，亲

王阳 发表于 2012-11-24 21:57
楼主的代码没啥问题啊,应该可以正常运行吧。

有问题，看图片，输入一片输出一片，我预想的是输入一个，输出一个

问题解决掉了。

转自CSDN... 当程序从wait()返回时是什么状态？ 是输出线程将信息取走了，运行了notify(),使输入线程继续运行，这时输入线程应该进行赋值操作。而楼主的代码，却有else语句，直接跳过了赋值语句。那它就是保持原来的值，所以会出现连续的相同的值。
把else 去掉即可。

代码中可使用while循环。让唤醒的线程再次判断条件。然后使用全唤醒notifyAll。问题即可解决。

王阳 发表于 2012-11-24 21:57
楼主的代码没啥问题啊,应该可以正常运行吧。

对啊、他问的问题你没看见啊？

楼主的代码没啥问题啊,应该可以正常运行吧。

1、为什么会有线程安全问题？
   原因：（1）多线程访问出现延迟（由于共享数据导致）；
         （2）线程的随机性（共享数据被多个线程操作）
2、怎么解决？
   （1）同步代码块
        具体格式：synchronized(对象){  需要同步的代码 }
     （2）使用 wait:让线程等待
           notify:唤醒单个线程
           notifyAll:唤醒所有线程