1. import java.util.concurrent.locks.*;
   
2. class  LockDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Res r=new Res();
   
7.                 new Thread(new Out1(r)).start();
   
8.                 new Thread(new Out2(r)).start();
   
9.                
   
10.                 //System.out.println("Hello World!");
    
11.         }
    
12. }
    
13. class Res
    
14. {
    
15.         private Lock lock=new ReentrantLock();
    
16.         private Condition con= lock.newCondition();
    
17.         private boolean flag=false;
    
18.         public void out1(int i)
    
19.         {
    
20.                 lock.lock();
    
21.                 try
    
22.                 {               
    
23.                         while(flag)
    
24.                                 con.await();  
    
25.                                 System.out.print(""+i+(++i));                        
    
26.                         flag=true;
    
27.                         con.signal();
    
28.                 }
    
29.                 catch (Exception e)
    
30.                 {
    
31.                 }
    
32.                 finally
    
33.                 {
    
34.                         lock.unlock();
    
35.                 }
    
36.         }
    
37.         public void out2(int i)
    
38.         {
    
39.                 lock.lock();
    
40.                 try
    
41.                 {                        
    
42.                         while(!flag)
    
43.                         try{con.await();}catch(Exception e){}                        
    
44.                         System.out.print((char)('A'+i));                        
    
45.                         flag=false;
    
46.                         con.signal();
    
47.                 }
    
48.                 catch (Exception e)
    
49.                 {
    
50.                 }
    
51.                
    
52.                 finally
    
53.                 {
    
54.                         lock.unlock();
    
55.                 }               
    
56.         }
    
57. }
    
58. class Out1 implements Runnable
    
59. {
    
60.         private Res r;
    
61.         Out1(Res r)
    
62.         {
    
63.                 this.r=r;
    
64.         }
    
65.         public void run()
    
66.         {        
    
67.                 for(int i=1;i<52;i+=2)
    
68. 
    
69.                         r.out1(i);
    
70.         }
    
71. }
    
72. class Out2 implements Runnable
    
73. {
    
74.         private Res r;
    
75.         Out2(Res r)
    
76.         {
    
77.                 this.r=r;
    
78.         }
    
79.         public void run()
    
80.         {
    
81.                 for(int i=0;i<27;i++)
    
82. 
    
83.                         r.out2(i);
    
84.                
    
85.                
    
86.                         
    
87.         }
    
88. }

复制代码

我多线程run方法里面用的for循环，条件不满足后for循环结束 那run方法也该结束了吧  怎么不能自然终止呢  帮忙看下  谢谢

你这个程序我运行了一下,结果如下,我截图给你, 打印的最终结果为12A34B56C78D.........5152Z
不存在你说的那个问题啊 只不过 在这里你的RUN没有起到什么作用

while(flag)？被第二次调用时，你看它是什么值，这里死循环了吧！

for(int i=1;i<52;i+=2)
  r.out1(i);

public void out1(int i)
        {
                lock.lock();
                try
                {               
                        while(flag)
                                con.await();  
                        System.out.print(""+i+(++i));                        
                        flag=true;
                        con.signal();
                }
                catch (Exception e)
                {
                }
                finally
                {
                        lock.unlock();
                }
        }
        public void out2(int i)
        {
                lock.lock();
                try
                {                        
                        while(!flag)//当out1执行最后一次后，此条件成立，out2就挂在里面了，out1再也不回来叫醒他
                        try{con.await();}catch(Exception e){}                        
                        System.out.print((char)('A'+i));   //打印的Z后，out1只剩最好一次,就执行完了                  
                        flag=false;
                        con.signal();
                }
                catch (Exception e)
                {
                }
               
                finally
                {
                        lock.unlock();
                }               
        }
//out1最后执完，out2进去睡觉了，然后再也没有人叫醒他了

朱荣宁. 发表于 2013-3-7 01:27
你这个程序我运行了一下,结果如下,我截图给你, 打印的最终结果为12A34B56C78D.........5152Z
不存在你说的 ...

我是问  程序自然终止了吗    没有吧  你必须 ctrl+c 一下吧   run没用？   这是多线程必须要写的方法啊

谢洋 发表于 2013-3-7 01:35
public void out1(int i)
        {
                lock.lock();

应该不会吧  当out1  打印完5152后  会把flag 置为 true  唤醒out2   自己出去  看for循环  不满足  结束   out2醒了  判断 flag  可以 打印  Z   完了出去看for循环  不满足 也该结束吧

门文通 发表于 2013-3-8 03:07
应该不会吧  当out1  打印完5152后  会把flag 置为 true  唤醒out2   自己出去  看for循环  不满足  结束 ...

真的说错了 应这样子说的：           
                            while(!flag)//下面把flag变为false，此条件成立，out2就挂在里面了，out1再也不回来叫醒他
                        try{con.await();}catch(Exception e){}                        
                        System.out.print((char)('A'+i));   //打印的Z之前（不是之后），out1刚执行完最后一个，                  
                        flag=false;//到这里，out2把flag变成false,所以上面while(!flag)//可以进入等行状态了

谢洋 发表于 2013-3-8 07:59
真的说错了 应这样子说的：           
                            while(!flag)//下面把flag变为false ...

你画的这三个  应该是先执行的中间的打印动作吧     此时打印的是Y？   如果是Y  那out1就还没执行打印5152   因为必须式交替的     如果是Z  那就打印完了  出去判断循环就行了  

如果是Y   然后吧flag变成false   出去判断  
1  如果再进来  wait了   那out1 先打印51 52   再把out2唤醒  那就没问题
2  如果没进来   out1先执行了   等out1执行完  会把flag 变成true  out2再进来  也没问题   

我qq 584910419   可以的话加一下  探讨一下  呵呵