程序结果不对，帮忙调下。就是两个线程给一个Person一个加血~一个减血。
我想要的结果是Person 失血而亡，但是结果是满血复活...帮忙调下。

1. class MyTest
   
2. {       
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Person p = new Person();
   
6.                 new Thread(new AddLife(p)).start();
   
7.                 new Thread(new HurtLife(p)).start();               
   
8.         }
   
9. 
   
10. }
    
11. 
    
12. class Person
    
13. {
    
14.         private int life = 10000;
    
15.         /*加血*/
    
16.         public void addLife(){
    
17.                 life+=20;
    
18.                 System.out.println("Person加了"+20+"的血，现在Life值是："+life);
    
19.         }
    
20.         /*减血*/
    
21.         public void hurtLife(int x){
    
22.                 if(x>life){
    
23.                         /*伤害值如果大于life，
    
24.                         则life值直接为0；
    
25.                         */
    
26.                         life=0;
    
27.                 }else{
    
28.                         life-=x;                       
    
29.                 }
    
30.                 System.out.println("Person受到"+x+"伤害，现在Life值是："+life);
    
31.         }
    
32.        
    
33.         public int getLife(){//get
    
34.                 return life;
    
35.         }
    
36. }
    
37. 
    
38. class AddLife implements Runnable
    
39. {
    
40.         private Person p;
    
41.         AddLife(Person p){this.p=p;}
    
42.        
    
43.         public void run(){               
    
44.                 while(true){
    
45.                         synchronized(p){
    
46.                                 if(p.getLife()<9000)//如果life值小于9000开始加血
    
47.                                 {
    
48.                                         p.addLife();
    
49.                                 }
    
50.                         }       
    
51.                 }               
    
52.         }
    
53. }
    
54. 
    
55. class HurtLife implements Runnable
    
56. {
    
57.         private Person p;
    
58.         HurtLife(Person p){this.p=p;}
    
59. 
    
60.         public void run(){               
    
61.                 while(true){
    
62.                         synchronized(p){
    
63.                                 if(p.getLife()>0){//大于零开始减血
    
64.                                         p.hurtLife(200);
    
65.                                 }
    
66.                                 else if (p.getLife()==0)//等于零表示挂了，程序退出。
    
67.                                 {
    
68.                                         System.out.println("Person挂了");
    
69.                                         return;
    
70.                                 }
    
71.                         }                       
    
72.                 }               
    
73.         }
    
74. }

复制代码

1. class MyTest
   
2. {        
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Person p = new Person();
   
6.                 new Thread(new AddLife(p)).start();
   
7.                 new Thread(new HurtLife(p)).start();               
   
8.         }
   
9. 
   
10. }
    
11. 
    
12. class Person
    
13. {
    
14.         private int life = 10000;
    
15.         /*加血*/
    
16.         public void addLife(){
    
17.                 life+=20;
    
18.                 System.out.println("Person加了"+20+"的血，现在Life值是："+life);
    
19.         }
    
20.         /*减血*/
    
21.         public void hurtLife(int x){
    
22.                 if(x>life){
    
23.                         /*伤害值如果大于life，
    
24.                         则life值直接为0；
    
25.                         */
    
26.                         life=0;
    
27.                 }else{
    
28.                         life-=x;                        
    
29.                 }
    
30.                 System.out.println("Person受到"+x+"伤害，现在Life值是："+life);
    
31.         }
    
32.         
    
33.         public int getLife(){//get
    
34.                 return life;
    
35.         }
    
36. }
    
37. 
    
38. class AddLife implements Runnable
    
39. {
    
40.         private Person p;
    
41.         AddLife(Person p){this.p=p;}
    
42.         
    
43.         public void run(){               
    
44.                 while(true){
    
45.                         synchronized(p){
    
46.                                 if(p.getLife()<9000)//如果life值小于9000开始加血
    
47.                                 {
    
48.                                         p.addLife();
    
49.                                 }
    
50.                         }        
    
51.                 }               
    
52.         }
    
53. }
    
54. 
    
55. class HurtLife implements Runnable
    
56. {
    
57.         private Person p;
    
58.         HurtLife(Person p){this.p=p;}
    
59. 
    
60.         public void run(){               
    
61.                 while(true){
    
62.                         synchronized(p){
    
63.                                 if(p.getLife()>0){//大于零开始减血
    
64.                                         p.hurtLife(200);
    
65.                                 }
    
66.                                 else if (p.getLife()==0)//等于零表示挂了，程序退出。
    
67.                       {
    
68.                                          System.out.println("Person挂了 GAME OVER!");
    
69.                                         //return;  把return去掉  既然挂了 还return干啥  
    
70.                            //直接退出就行 程序不退出 就一直会处于加血状态。。
    
71.                            System.exit(0);// 当没血的时候退出程序 GAME OVER!                              
    
72.                                    }
    
73.                         }                        
    
74.                 }               
    
75.         }
    
76. }

复制代码