生产者与消费者模式的同步问题

kevinmit

读教程时，遇到了生产者与消费者的例子，还有代码，运行后，出错，自己修改，正常，但是，却发生严重不同步问题。
如：生产者：a
    消费者：a
    生产者：b
    生产者：g
    生产者：p
    消费者：p
    消费者: p

请大家帮忙指定：谢谢！

代码如下:
class Producer extends Thread
{
   private Soup soup;
   private String alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   public Producer(Soup s)
   {
     soup=s;
   }
   public void run()
   {
     char c;
     for(int i=0;i<10;i++)
     {
        c=alphabet.charAt((int)(Math.random()*26));
        soup.add(c);
        System.out.println("Added  "+c+"  tothesoup.";
        try
         {
            sleep((int)(Math.random()*1000));
         }
        catch(InterruptedException e)
         {
         }
     }
   }
}

class Consumer extends Thread
{
  private Soup soup;
  public Consumer(Soup s)
  {
    soup=s;
  }
  public void run()
  {
    char c;
    for(int i=0;i<10;i++)
    {
      c=soup.eat();
      System.out.println("Atealetter: "+c);
      try
      {
        sleep((int)(Math.random()*1300));
      }
      catch(InterruptedException e)
      {
      }
    }
   }
}


class Soup
{
  private char buffer[]=new char[10];
  private int next=0;
  private boolean isFull=false;
  private boolean isEmpty=true;

  public synchronized char eat()
  {
   while(isEmpty==true)
   {
    try
    {
      wait();
    }
    catch(InterruptedException e)
    {
    }
   }
   if(next==0)
   {
    isEmpty=true;
   }
   isFull=false;
   notify();
   return(buffer[next-1]);
  }

  public synchronized void add(char c)
  {
    while(isFull==true)
    {
      try
      {
       wait();
      }
      catch(InterruptedException e)
      {
      }
    }
      if(next==10)
          {
              isFull=true;
      }
      buffer[next]=c;
      next++;
      isEmpty=false;
      notify();
  }
}

class Souptest
{
  public static void main(String args[])
  {
          Soup s=new Soup();
          Producer p1=new Producer(s);
          Consumer c1=new Consumer(s);
          p1.start();
          c1.start();
  }
}

sakulagi

1. 
   
2. class Producer extends Thread {
   
3.         private Soup soup;
   
4.         private String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   
5.         public Producer(Soup s) {
   
6.                 soup = s;
   
7.         }
   
8.         public void run() {
   
9.                 char c;
   
10.                 for (int i = 0; i < 10; i++) {
    
11.                         c = alphabet.charAt((int) (Math.random() * 26));
    
12.                         soup.add(c);
    
13.                         System.out.println("Added " + c + " tothesoup.");
    
14.                         try {
    
15.                                 sleep((int) (Math.random() * 1000));
    
16.                         } catch (InterruptedException e) {
    
17.                         }
    
18.                 }
    
19.         }
    
20. }
    
21. class Consumer extends Thread {
    
22.         private Soup soup;
    
23.         public Consumer(Soup s) {
    
24.                 soup = s;
    
25.         }
    
26.         public void run() {
    
27.                 char c;
    
28.                 for (int i = 0; i < 10; i++) {
    
29.                         c = soup.eat();
    
30.                         System.out.println("Atealetter: " + c);
    
31.                         try {
    
32.                                 sleep((int) (Math.random() * 1300));
    
33.                         } catch (InterruptedException e) {
    
34.                         }
    
35.                 }
    
36.         }
    
37. }
    
38. class Soup {
    
39.         private char buffer[] = new char[10];
    
40.         private int next = 0;
    
41.         private boolean isFull = false;
    
42.         private boolean isEmpty = true;
    
43.         public synchronized char eat() {
    
44.                 while (isEmpty == true) {
    
45.                         try {
    
46.                                 wait();
    
47.                         } catch (InterruptedException e) {
    
48.                         }
    
49.                 }
    
50.                 if (next == 1) {
    
51.                         isEmpty = true;
    
52.                 }
    
53.                 isFull = false;
    
54.                 notify();
    
55.                 return (buffer[--next]);
    
56.         }
    
57.         public synchronized void add(char c) {
    
58.                 while (isFull == true) {
    
59.                         try {
    
60.                                 wait();
    
61.                         } catch (InterruptedException e) {
    
62.                         }
    
63.                 }
    
64.                 if (next == 10) {
    
65.                         isFull = true;
    
66.                 }
    
67.                 buffer[next] = c;
    
68.                 next++;
    
69.                 isEmpty = false;
    
70.                 notify();
    
71.         }
    
72. }
    
73. public class SoupTest {
    
74.         public static void main(String args[]) {
    
75.                 Soup s = new Soup();
    
76.                 Producer p1 = new Producer(s);
    
77.                 Consumer c1 = new Consumer(s);
    
78.                 p1.start();
    
79.                 c1.start();
    
80.         }
    
81. }
    

复制代码

下次贴代码记得保持格式。你的哪个帖子完全没有缩进。

kevinmit

感谢朋友帮忙 真心谢谢
同时也记住了你的忠告 以后发代码一定会注意的

不过 由于本人太愚 还想问一下 为什么把

1. 
   
2. if(next==0)
   
3. {
   
4. isEmpty=true;
   
5. }
   

复制代码

改为

1. 
   
2. if(next==1)
   
3. {
   
4. isEmpty=true;
   
5. }
   

复制代码

呢？
又麻烦你了！

sakulagi

因为你是在consume之前就判断，也就是在取数据之前，这个时候，只要还剩一个字母，那么取了之后就会变成next=0，也就是empty了。如果你是在

1. return (buffer[--next]);
   

复制代码

之后判断，那么就是

1. if (next == 0) ...

复制代码

quanliking

稍改了一下，我用了另外一种方法，采用双指针对 buffer 进行控制。

1. 
   
2. class Producer extends Thread {
   
3.         private Soup soup;
   
4.         private String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   
5.         public Producer(Soup s) {
   
6.                 soup = s;
   
7.         }
   
8.         public void run() {
   
9. 
   
10.                 for ( int i = 0; i <= 10; i++ )
    
11.                 {
    
12.                         try {
    
13.                                 sleep( ( int )  ( Math.random() * 1000 ) );
    
14.                                 char c = alphabet.charAt( ( int ) ( Math.random() * 26 ) );
    
15.                                 soup.add( c );
    
16.                                 System.out.println("Producer: add a letter " + c);
    
17.                         }
    
18.                         catch (InterruptedException exception) {
    
19.                                 exception.printStackTrace();
    
20.                         }
    
21.                 }
    
22.         }
    
23. }
    
24. 
    
25. class Consumer extends Thread {
    
26.         private Soup soup;
    
27.         public Consumer(Soup s) {
    
28.                 soup = s;
    
29.         }
    
30.        
    
31.         public void run() {
    
32.                 for ( int i = 0; i <= 10; i++ )
    
33.                 {
    
34.                         try {
    
35.                                 sleep( ( int ) ( Math.random() * 1000 ) );
    
36.                                 char c = soup.eat();
    
37.                                 System.out.println("Consumer: eat a letter " + c);
    
38.                         }
    
39.                         catch (InterruptedException exception) {
    
40.                                 exception.printStackTrace();
    
41.                         }
    
42.                 }
    
43.         }
    
44. }
    
45. 
    
46. class Soup {
    
47.         private char buffer[] = new char[10];
    
48.        
    
49.         // nextFree points to the next free position int the buffer
    
50.         // firstFull  points to the first full position in the buffer
    
51.         private int nextFree = 0, firstFull = 0;       
    
52.                
    
53.         private boolean isEmpty = true;
    
54.         private boolean isFull = false;
    
55. 
    
56.         public synchronized char eat() {
    
57.                 while ( isEmpty == true ) {
    
58.                         try {
    
59.                                 wait();
    
60.                         }
    
61.                         catch (InterruptedException exception) {
    
62.                                 exception.printStackTrace();
    
63.                         }
    
64.                 }
    
65.                 firstFull = ( firstFull + 1 ) % buffer.length;
    
66.                 if ( firstFull == nextFree )
    
67.                 {
    
68.                         isEmpty = true; // buffer is  Empty
    
69.                 }
    
70.                 isFull = false; // buffe is not full, maybe empty or not
    
71.                 notify();
    
72.                 return ( buffer[ ( firstFull + buffer.length - 1 ) % buffer.length ] );
    
73.         }
    
74. 
    
75.         public synchronized void add(char c) {
    
76.                 while ( isFull == true ) {
    
77.                         try {
    
78.                                 wait();
    
79.                         }
    
80.                         catch ( InterruptedException exception ) {
    
81.                                 exception.printStackTrace();
    
82.                         }
    
83.                 }
    
84.                 buffer[ nextFree ] = c;
    
85.                 nextFree = ( nextFree + 1 ) % buffer.length;
    
86.                 if ( ( ( nextFree + 1 ) % buffer.length )  == firstFull )
    
87.                 {
    
88.                         isFull = true; // buffer is full
    
89.                 }
    
90.                 isEmpty = false; // buffer is not empty, maybe full or not
    
91.                 notify();
    
92.         }
    
93. }
    
94. 
    
95. class SoupTester {
    
96.         public static void main(String args[]) {
    
97.                 Soup s = new Soup();
    
98.                 Producer p1 = new Producer(s);
    
99.                 Consumer c1 = new Consumer(s);
    
100.                 p1.start();
     
101.                 c1.start();
     
102.         }
     
103. }
     

复制代码

[/code]

QuanTou

前面的程序
try {  
        soup.add(c);    //////////应该放到try 里面，不然会死锁，
         System.out.println("Added " + c + " tothesoup.";
      
            sleep((int) (Math.random() * 1000));
         } catch (InterruptedException e) {
         }

private char buffer[] = new char[2]; ///10 改到2 就很容易看到了

我这样说对吗？？
第二条的 eat 和add 放在 try 里就没事