代码如下，5个线程不同步？why？？？？？

1. import java.io.BufferedReader;
   
2. import java.io.IOException;
   
3. import java.io.InputStreamReader;
   
4. 
   
5. public class threaddemo {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 // TODO Auto-generated method stub
    
12.                 BufferedReader br = null;
    
13.                 String str;       
    
14.                 productor pr=new productor();
    
15.                 System.out.println("输入 “start” 开始");
    
16.                 while(true)
    
17.                 {
    
18.                         try{
    
19.                                
    
20.                                 br=new BufferedReader(new InputStreamReader(System.in));
    
21.                                 str=br.readLine();
    
22.                                 if(str.equals("start")){
    
23.                                         new Thread(new pro(pr)).start();//创建2个生产线程，3个消费线程
    
24.                                         new Thread(new pro(pr)).start();
    
25.                                         new Thread(new com(pr)).start();
    
26.                                         new Thread(new com(pr)).start();
    
27.                                         new Thread(new com(pr)).start();
    
28.                                 }
    
29.                                
    
30.                         }
    
31.                         catch(IOException e){}
    
32.                         finally{
    
33.                                 try{
    
34.                                         if(br!=null);
    
35.                                         br.close();
    
36.                                 }
    
37.                                 catch(IOException e){}
    
38.                         }
    
39.                        
    
40.                 }
    
41.                
    
42.         }
    
43. 
    
44. }
    
45. 
    
46. class pro implements Runnable//生产线程
    
47. {
    
48.         productor pp;
    
49.         pro(productor pp){
    
50.                 this.pp=pp;
    
51.         }
    
52.         public void run(){
    
53.                 while(true){
    
54.                 pp.set();
    
55.                 }
    
56.         }
    
57.        
    
58. }
    
59. 
    
60. class com implements Runnable//消费线程
    
61. {
    
62.         productor pp;
    
63.         com(productor pp){
    
64.                 this.pp=pp;
    
65.         }
    
66.         public void run(){
    
67.                 while(true){
    
68.                 pp.get();
    
69.                 }
    
70.         }
    
71.        
    
72. }
    
73. class productor //要操作的资源类
    
74. {
    
75.        
    
76.         String p1;
    
77.         String p2;       
    
78.         boolean flag=false;
    
79.         int count=0;
    
80.         public synchronized void set()//生产方法
    
81.         {
    
82.                   
    
83.                 if(flag){
    
84.                         try{wait();}catch(Exception e){}
    
85.                                
    
86.                 }
    
87.                
    
88.                 this.p1="牛奶";
    
89.                 this.p2="可乐";
    
90.                 flag=true;
    
91.                 System.out.println("线程："+Thread.currentThread().getName()+"生产 "+(count++)+"个产品"+p1+"   "+p2);
    
92.                 notifyAll();
    
93.                
    
94.                  
    
95.         }
    
96.         public synchronized void get()//取出方法，即消费
    
97.         {
    
98.                
    
99.                 if(!flag){
    
100.                        
     
101.                         try
     
102.                         {wait();
     
103.                         }
     
104.                         catch(Exception e){
     
105.                                 System.out.println("线程等待失败");
     
106.                         }
     
107.                        
     
108.                 }
     
109.                 flag=false;
     
110.                 System.out.println("线程："+Thread.currentThread().getName()+"消费    "+count+"个产品"+p1+"   "+p2);
     
111.                 notifyAll();
     
112.                
     
113.         }
     
114.        
     
115. }

复制代码

大神何在~~:'(

顶上去:dizzy:

你这样写优点混乱，先把get（）方法放回到消费者类里面，再试试。

还有flag最好声明在Product类里面，生产者或消费者调用pp.flag

顶上去啊~~~

大神来解决啊

你想生产消费交替执行吗？

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Demo {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                BufferedReader br = null;
                String str;        
                productor pr=new productor();
               // System.out.println("输入 “start” 开始");
               // while(true)
               // {
                   //     try{
                                
                            //    br=new BufferedReader(new InputStreamReader(System.in));
                             //   str=br.readLine();
                              //  if(str.equals("start")){
                                        new Thread(new pro(pr)).start();//创建2个生产线程，3个消费线程
                                        new Thread(new pro(pr)).start();
                                        new Thread(new com(pr)).start();
                                        new Thread(new com(pr)).start();
                                        new Thread(new com(pr)).start();
                             //   }
                                
                       // }
                       // catch(IOException e){}
                       /// finally{
                        //        try{
                             //           if(br!=null);
                            //            br.close();
                             //   }
                             //   catch(IOException e){}
                       // }
                        
                //}
               
        }

}

class pro implements Runnable//生产线程
{
        productor pp;
        pro(productor pp){
                this.pp=pp;
        }
        public void run(){
                while(true){
                pp.set();
                }
        }
        
}

class com implements Runnable//消费线程
{
        productor pp;
        com(productor pp){
                this.pp=pp;
        }
        public void run(){
                while(true){
                pp.get();
                }
        }
        
}
class productor //要操作的资源类
{
        
        String p1;
        String p2;        
        boolean flag=false;
        int count=0;
        public synchronized void set()//生产方法
        {
                  
                while(flag){
                        try{wait();}catch(Exception e){}
                                
                }
               
                this.p1="牛奶";
                this.p2="可乐";
                //flag=true;
                System.out.println("线程："+Thread.currentThread().getName()+"生产 "+(count++) +p1+"   "+p2);
                                flag=true;
                notifyAll();
               
                 
        }
        public synchronized void get()//取出方法，即消费
        {
               
                while(!flag){
                        
                        try
                        {wait();
                        }
                        catch(Exception e){
                                System.out.println("线程等待失败");
                        }
                        
                }
                //flag=false;
                System.out.println("线程："+Thread.currentThread().getName()+"消费 "+(count++) +p1+"   "+p2);
                                flag=false;
                notifyAll();
               
        }
        
}

这是我修改的，不知道你是不是这个意思，现在是生产一个消费一个

多个线程间通信需要使用while而不是if，例如生产者生产好产品，这时应该唤醒消费者消费，而使用notifyAll是将所有的线程全部唤醒，这时使用了if判断语句，因为if语句上次已经判断过了，可能生产线程进入判断后等待执行，可能生产者又会抢到CUP执行权执行生成线程，造成线程不同步。而使用while的情况则不同，生产者生成产品后唤醒所有线程，while语句会再次循环判断flag标识，如果flag为真，则生产线程继续wait，消费线程其中一个得到CPU执行权，消费产品。这样解释原理不知清楚否？