/*多线程_等待唤醒机制*/

/**
*需求：创建两个线程，一个进行存储信息，一个进行打印信息。
*目的：程序输入一个"mike man"打印一个"mike man"
*           输入一个"莉莉 女女女女女"打印一个"莉莉 女女女女女"
*步骤：创建一个共享资源类RescourceWaitNotifyDemo
*                创建输入线程类InputWaitNotifyDemo
*                创建打印线程类OutputWaitNotifyDemo
*                由主函数创建线程，并执行。
*问题：
*                求大虾回答这里线程安全问题在哪里？
*                怎么解决？
*/

/*线程共享资源类，信息类*/

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

复制代码

如果问题已经解决，请及时修改主题为“提问结束”。
修改主题的方法链接
http://bbs.itheima.com/thread-89313-1-1.html

加个同步锁，synchronized 和Lock，但Lock必须要手工释放，你这儿先必须让写线程先执行，读进程后执行。