1. 
   

复制代码

class Test implements Runnable
{
     int num=0;
      public synchronized void run()
     {
         while(true)
      {
         if(num==20)
                 return;//完全可以把子线程完全控制住，使其终止。
        System.out.println(Thread.currentThread().getName+num);
        num++;
      }
}
}
public class Demo
{
      public static void main(String[] args)
     {
            Test t=new Test();
            new Thread(t).start();
            new Thread(t).start();
     }
}

但是如下方式就不行：
class Test implements Runnable
{
     int num=0;
      public synchronized void run()
     {
         while(true)
      {
         if(num++==20)
                 return;//不可以把子线程完全控制住，使其终止！！郁闷！！！！求大神！！！。
        System.out.println(Thread.currentThread().getName+num);
      }
}
}
public class Demo
{
      public static void main(String[] args)</P>
     {
            Test t=new Test();
            new Thread(t).start();
            new Thread(t).start();
     }

num++==20是先比较，在自加。。
第一种方式：线程一num=20时，执行到到if(num==20) 会执行return方法，程序执行结束，num=20，所以是使用的同一个对象t，此时thread1执行，线程2进入，一进来就发现num=20,也会执行return方法，程序执行结束。

第2中方式：当num=20，执行if(num++==20),是先比较num==20，然后再加++，发现num=20，执行return
，线程程序结束，执行的num=21，线程2进入是num=21，所以就不会执行return，一直循环。。

1. package itheima.test;
   
2. 
   
3. 
   
4. //但是如下方式就不行：
   
5. class Test implements Runnable
   
6. {
   
7.      int num=0;
   
8.       public synchronized void run()
   
9.      {
   
10.          while(num<=20)//把这个条件改下就可以，当然逻辑就乱了
    
11.       {
    
12.                
    
13.          if(num++==20)
    
14.                  return;//不可以把子线程完全控制住，使其终止！！郁闷！！！！求大神！！！。
    
15.         System.out.println(Thread.currentThread().getName()+"//"+num);
    
16.       }
    
17. }
    
18. }
    
19. public class Demo
    
20. {
    
21.       public static void main(String[] args)
    
22.      {
    
23.             Test t=new Test();
    
24.             new Thread(t).start();
    
25.             new Thread(t).start();
    
26.      }
    
27.   }

复制代码

哈哈，是个好问题！原因在于：
num在return前自增和在return后自增是有区别的：

1.          while(true)
   
2.       {
   
3.          if(num==20)
   
4.                  return;//完全可以把子线程完全控制住，使其终止。
   
5.         System.out.println(Thread.currentThread().getName+num);
   
6.         num++;
   
7.       }

复制代码

第一种写法把num++写在return后，当一条线程运行到return退出后，num依然是20，执行不到num++，另外一条线程过来判断条件num==20，所以也执行return退出。

1.          while(true)
   
2.       {
   
3.          if(num++==20)
   
4.                  return;//不可以把子线程完全控制住，使其终止！！郁闷！！！！求大神！！！。
   
5.         System.out.println(Thread.currentThread().getName+num);
   
6.       }

复制代码

当你把num++放在return前，情况就不同了。当num=20时，第一条线程判断（return++ ==20）时，是先判断==，再自增，所以ture，num变成21，接着运行return退出.第二条线程过来，(此时num=21)，判断num++ ==20，false，就不执行return语句了。

librazeng 发表于 2013-6-8 12:10
哈哈，是个好问题！原因在于：
num在return前自增和在return后自增是有区别的：第一种写法把num++写在retur ...

是的啊，嘿嘿嘿。谢谢了

楼主你好  如果帖子的问题已经解决，请把帖子的类型改为“已解决”。{:soso_e102:}