Erzeuger-Verbraucher-Synchronisation mit

Question

schrieb ich Code, um das Erzeuger-Verbraucher-Problem zu implementieren und es scheint in Ordnung, ohne die Notwendigkeit zu synchronize.Is zu arbeiten, es möglich?

Wie kann ich den Code testen und prüfen, ob es tatsächlich richtig funktioniert oder nicht? Wie kann ich wissen, ob Deadlock auftreten wird? Gerade jetzt, ich breche nicht aus den Schlingen (dh des Hersteller hält das Einfügen und der Verbraucher hält in einer Endlosschleife raubend) .Ich ist eine kreisförmige Warteschlange der Größe 3 (der Einfachheit halber), wobei als gemeinsame Ressource.

Hier ist mein Code:

import java.util.*;

public class PCImpl implements Runnable 
{
Thread t;
QforPC qObj;

 public static void main(String[] args)
 {
     QforPC qObject=new QforPC();

     //These create 2 different objects! Each object has it's own thread of execution.
     //Synchronization is needed when 2 threads use the same object
    new PCImpl("Producer",qObject);
    new PCImpl("Consumer",qObject);
 }

 PCImpl(String name,QforPC qObj)
 {
     this.qObj=qObj;
     t=new Thread(this,name);
     t.start();
 }

 public void run()
 {
         if(Thread.currentThread().getName().equals("Producer"))
         {
             while(true)
             {
                  Random rgen=new Random();
                  int n=rgen.nextInt(100);
                  if(n!=0)
                              qObj.Producer(n);
                         try
                    {
                       Thread.sleep(200);
                     }
                      catch(InterruptedException e)
                    {

                    }
               }

            }


         if(Thread.currentThread().getName().equals("Consumer"))
         {
             while(true)
                  {
                 try
               {
                 Thread.sleep(1500);
               }
                catch(InterruptedException e)
               {
                  }
              qObj.Consumer();

              }
         }

  }
}



public class QforPC 
{
int[] q={0,0,0};
int r=0,f=0;
  public void Producer(int item)
     {

         if(r!=q.length && canProducer())
         {
             q[r]=item;
             System.out.println("The item inserted into the queue is:"+ item);
             r++;
         }
         if(r==q.length && f>0)
             r=0;
         else if(r==q.length && f==q.length)
         {
             r=0;
             f=0;
         }
     }

     public void Consumer()
     {
         int item;
         System.out.println("The value of isQueue empty is:"+ isEmpty());

         if(f!=q.length && isEmpty()==false)
         {
             System.out.println("Entered the consumer method");
             item=q[f];
             System.out.println("The item fetched from the queue is:"+item);
             q[f]=0;
             f++;
         }
         if(f==q.length && r<f)
             f=0;

     }

     public boolean isEmpty()
     {
         for(int k=0;k<q.length;k++)
         {
             if(q[k]==0 && k==q.length-1)
                 return true;

         }
         return false;
     }

     public boolean canProducer()
     {
         for(int k=0;k<q.length;k++)
         {
                 if(q[k]==0)
                 return true;

         }
         return false;
     }
} 

Answer 1

Was Sie versucht haben zu tun ist, implementieren Synchronisation busy-Warte verwenden. In Pseudo-Code, was Sie im Grunde tun, ist:

Producer()
{
   if (buffer.hasemptyspaces())
   {
      produce(buffer);
   }
   else
   {
      sleep(n);
   }
}

Consumer()
{
   if (buffer.hasfullspaces())
   {
      consume(buffer);
   }
   else
   {
      sleep(n);
   }
}

Sie werden Code funktionieren, bis die der Erzeuger und Verbraucher versuchen, gleichzeitig produzieren execute () und verbrauchen (). Mit anderen Worten, entweder eines der Dies könnte nicht sehr oft, aber ist auf jeden Fall möglich und wird auf jeden Fall passieren!

In Java ConcurrentLinkedQueue auf Geräte ein Wartefreies Algorithmus für einen gemeinsamen Puffer. Ich bin sicher, dass es andere Implementierungen, wenn man sich umschaut.

Answer 2

Es gibt nicht so etwas wie the Producer-Consumer problem. Producer-Consumer ist ein Entwurfsmuster, die keine effektive Implementierung einer Lösung für ein Problem sein können oder nicht, kein Problem an und für sich.

Ich bin sicher, es gibt viele Erzeuger-Verbraucher-Implementierungen, die synching nicht benötigen. Es hängt ganz davon ab, was Sie versuchen Art von Daten zu erreichen und was Sie produzieren / raubend.

Außerdem haben Sie ein Problem haben, zu lösen, wenn Sie Sie sind Implementierung Werke sagen wollen, ohne Synchronisierung. Arbeitet an, was zu tun? Ich habe keine Ahnung, was du tust.

Answer 3

Es kann mit einer Sperre freie Warteschlange getan werden, aber nicht so, ich empfehlen, dass Sie Java Concurrency in Practice lesen. Wenn Ihr Code den Zugriff durch mehrere Threads gleichzeitig werden Sie auf, dass viele erros haben, haben Sie die Veröffentlichung und syncronizations Probleme !! Aber wie Farlmarri sagte, es auf die Verwendung dieses Codes abhängig ist.

Answer 4

Sie sind eigentlich nicht die Erzeuger / Verbraucher-Problem zu lösen, sondern nur um es zu Fuß :) Ihr Code funktioniert, weil der Zeitpunkt und aufgrund der Tatsache, wenn eine der beiden Fäden reißen setzen / Abrufen der Ressource fragt er es im Grunde für eine Weile und versucht wieder schläft. Obwohl diese worsk (wenn Sie nicht haben, um sofort ein Ereignis zu behandeln) es verschwendet CPU-Zeit.

Deshalb Semaphore sind stark, diese Art von Problem vorgeschlagen zu adressieren, wie Sie hier lesen

http://en.wikipedia.org/wiki/Producer-consumer_problem

Auf Wiedersehen