synchronisierte Methode mit warte bediengungen

Shakra

Aktives Mitglied
Hi zusammen,
ich bin grad vor einer ganz wichtigen Aufgabe, nämlich eine synchronisierte Methode die mit einer Bedingung verknüpft werden soll.

Also eine konkrete Problemstellung in einem Produzent-Konsument Konzept lautet z.B: Die Ressourcen sollen unter den (im Monitor)wartenden Konsumenten nach dem FIFO Prinzip verteilt werden.

So und meine Frage ist was mach ich jetzt?
Also ich würde sagen, zuerst macht man eine Warteliste in dem man eine boolean array wartend deklariert und im try block vor dem wait() mit dem jeweiligen index mit true initialisiert.
Jetzt weiss man wer wartet aber man hat keine reihenfolge..
Dafür müsste man wahrscheinlich noch eine array varible haben die man vor wait mit dem jeweiligen index initialisiert. Aber wie mache ich das?
Und wie formuliere ich die schleifenbedingung?boolean wartend wäre ja dann schon im schleifen körper initialisiert, also nützt es mir bei der formulierung der bedingung auch gar nicht..Soll ich also eine Methode mit diesen parametern schreiben aber wie sehe es aus..

Hier habe aufjedenfall noch einen entsprechenden code:
Java:
public class Haupt
{
public static void main(String[] unbenutzt)
{ Lager L = new Lager();
Produzent P = new Produzent(L); P.start();
Konsument[] K = new Konsument[4];
for (int i = 1; i <= 3; i++)
{ K[i] = new Konsument(i, L); K[i].start(); }
}
}
class Lager
{ int Warenanzahl = 0;
synchronized void erzeugt() { Warenanzahl++; notify();}
synchronized void entnimm()
{ while (Warenanzahl == 0)
try {wait(); } catch(InterruptedException e) { }
Warenanzahl--;
}
}
class Produzent extends Thread
{ Lager L; long Startzeit = System.nanoTime();
Produzent(Lager L) { this.L = L; }
public void run()
{ while (System.nanoTime() - Startzeit < 20000000000L)
{ long t = (long) (50 * Math.random()); // Produktionsdauer zufällig.
try { sleep(t); } catch(InterruptedException e) { }
L.erzeugt();
}
}
}
class Konsument extends Thread
{ int Index; Lager L; long Startzeit = System.nanoTime();
Konsument(int i, Lager L) { Index = i; this.L = L; }
public void run()
{ while (System.nanoTime() - Startzeit < 20000000000L)
{ long t = (long) (150 * Math.random()); // Wartedauer zufällig.
try { sleep(t); } catch(InterruptedException e) { }
L.entnimm();
}
}
}
 
Die Methoden hinzufügen und entnehmen synchronized machen. Wenn etwas hinzugefügt wurde, notifyAll() aufrufen. Wenn aus einer leeren Queue etwas entnommen werden soll, wait() aufrufen

Btw: Den Sourcecode hättest du auch mal formatieren können, so liest sich das ja keiner durch 😱
 
Zuletzt bearbeitet von einem Moderator:
Schau dir mal die Klasse [JAPI]
java.util.concurrent.ArrayBlockingQueue
[/JAPI] an.

Die macht genau das was die Aufgabe verlangt. Da kannst du als Anhaltspunkt für deine Lösung verwenden.
Dabei kommt mir in den Sinn, das da ja schon das neue concurrency API verwendet wird, aber als Referenz ist sie sicher zu gebrauchen.
 

Zurück
Oben