1. class test implements Runnable
   
2. {
   
3.         private int x=0;
   
4.         Object obj=new Object();   
   
5.         public void run()      //重写RUN方法
   
6.         {        
   
7.                 while (x<100)   
   
8.                         {
   
9.                                 synchronized(obj)  //锁线程
   
10.                                         {               
    
11.                                                 System.out.println(Thread.currentThread().getName()+"-------"+x++)        ;//打印线程名  和X,
    
12.                                         }
    
13.                         }                        
    
14.         }
    
15.         
    
16. }
    
17. class  Dome
    
18. {
    
19.         public static void main(String[] args)
    
20.         {
    
21.                 test a1=new test();   //新建Test对象
    
22.                 Thread b1=new Thread(a1);  //新建四个线程
    
23.                 Thread b2=new Thread(a1);
    
24.                 Thread b3=new Thread(a1);
    
25.                 Thread b4=new Thread(a1);
    
26.                 b1.start();                                        //启动四个线程
    
27.                 b2.start();
    
28.                 b3.start();
    
29.                 b4.start();
    
30.                
    
31.                 /*
    
32.                 for (int x=0;x<100 ;x++ )
    
33.                         {
    
34.                                 System.out.println("x="+x);
    
35.                         }
    
36.                 */
    
37.         }
    
38. 
    
39. }

复制代码

帮我看看,我就感觉我的程序很有规律,每次最后都是到102,按道理应该到99才对啊,为什么多了三个啊!
然后线程也一直都抢不到,也不知道是真的抢不到,还是说程序有问题,反正就是说线程从0到99一直都是一个线程,就是最后三个不是.测试了好多遍了,都不行!

我上面已经帮你改了。。。。

1. class test implements Runnable {
   
2.         private int x = 0;
   
3.         Object obj = new Object();
   
4. 
   
5.         public void run() // 重写RUN方法
   
6.         {
   
7.                 synchronized (obj) // 锁线程
   
8.                 {
   
9.                         while (x < 100) {
   
10. 
    
11.                                 System.out.println(Thread.currentThread().getName() + "-------"
    
12.                                                 + x++);// 打印线程名 和X,
    
13.                         }
    
14.                 }
    
15.         }
    
16. 
    
17. }
    
18. 
    
19. public class Dome {
    
20.         public static void main(String[] args) {
    
21.                 test a1 = new test(); // 新建Test对象
    
22.                 Thread b1 = new Thread(a1); // 新建四个线程
    
23.                 Thread b2 = new Thread(a1);
    
24.                 Thread b3 = new Thread(a1);
    
25.                 Thread b4 = new Thread(a1);
    
26.                 b1.start(); // 启动四个线程
    
27.                 b2.start();
    
28.                 b3.start();
    
29.                 b4.start();
    
30. 
    
31.                 /*
    
32.                  * for (int x=0;x<100 ;x++ ) { System.out.println("x="+x); }
    
33.                  */
    
34.         }
    
35. 
    
36. }

复制代码

在同步代码里面加上一个 if(x<100)来判断一下就好了.
类似于单例设计模式的懒汉式那样..

public void run()      //重写RUN方法
        {       while(true){
                synchronized (obj) // 锁线程
                {
                        if(x < 100) {

                                System.out.println(Thread.currentThread().getName() + "-------"
                                                + x++);// 打印线程名 和X,
               
                        }
                       else
                       {
                             return;
                      }
                }
        }     

把循环放到同步外面，判断放到同步里面就行。

1. //把你的代码稍稍改动如下就可以了
   
2. 
   
3. class test implements Runnable
   
4. {
   
5.         private int x=0;
   
6.         Object obj=new Object();   
   
7.         public void run()      //重写RUN方法
   
8.         {        
   
9.                 while (true)
   
10.                         {
    
11.                                 synchronized(obj)  //锁线程
    
12.                                         {  
    
13.                                                                                         if (x < 100)//这里加多一个if判断就没问题了
    
14.                                                                                         {
    
15.                                                 System.out.println(Thread.currentThread().getName()+"-------"+x++)        ;//打印线程名  和X,
    
16.                                                                                         }
    
17.                                         }
    
18.                         }                        
    
19.         }
    
20.         
    
21. }
    
22. class  Dome
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26.                 test a1=new test();   //新建Test对象
    
27.                 Thread b1=new Thread(a1);  //新建四个线程
    
28.                 Thread b2=new Thread(a1);
    
29.                 Thread b3=new Thread(a1);
    
30.                 Thread b4=new Thread(a1);
    
31.                 b1.start();                                        //启动四个线程
    
32.                 b2.start();
    
33.                 b3.start();
    
34.                 b4.start();
    
35.                
    
36.                 /*
    
37.                 for (int x=0;x<100 ;x++ )
    
38.                         {
    
39.                                 System.out.println("x="+x);
    
40.                         }
    
41.                 */
    
42.         }
    
43. 
    
44. }
    

复制代码

黄小贝 发表于 2013-4-1 20:43
我上面已经帮你改了。。。。

你这样改的话,不就是相当于,第一个线程谁先进去,然后就一次性循环完,然后才能解锁码?那跟单线程有什么区别!

万蕾 发表于 2013-4-1 21:02
public void run()      //重写RUN方法
        {       while(true){
                synchronized (obj ...

豁然开朗!

李尧 发表于 2013-4-1 20:51
在同步代码里面加上一个 if(x

OK,明白了!