Hallo zusammen
Das rekursive Programm Türme von Hanoi ist hier gegeben.
Nun, der Code ist verständlich. Jetzt soll dieser aber mittels Producer-Consumer-Prinzip umgeformt werden.
Das Prinzip verstehe ich schon, aber wie kann ich es auf Hanoi umsetzen?
Kann ich hier ablage als Buffer verstehen?
Was ist hier Producer und was ist hier consumer?
Kann mir da jemand weiterhelfen?
Es währe gut, wenn ich die Aufgabe zusammen mit der Community lösen kann, ich "verlange" keine fertige Lösung, denn die hilft mir nicht beim verstehen des Prinzips.
Das rekursive Programm Türme von Hanoi ist hier gegeben.
Java:
public class Hanoi {
static void hanoi(int anzahlScheiben, String start, String ziel, String ablage)
{
if (anzahlScheiben <= 0) return;
hanoi(anzahlScheiben - 1, start, ablage, ziel);
zug(anzahlScheiben, start, ziel);
hanoi(anzahlScheiben - 1, ablage, ziel, start);
}
static void zug(int scheibe, String start, String ziel)
{
System.out.println("Scheibe " + scheibe + " von " + start + " nach " + ziel);
}
public static void main (String[] args)
{
hanoi(4, "A", "B", "C");
}
}Nun, der Code ist verständlich. Jetzt soll dieser aber mittels Producer-Consumer-Prinzip umgeformt werden.
Das Prinzip verstehe ich schon, aber wie kann ich es auf Hanoi umsetzen?
Java:
public class ProducerConsumer {
public static void main(String[] args)
{
Buffer b = new Buffer();
Consumer c = new Consumer(b);
Producer p = new Producer(b,1);
c.run();
p.run();
}
}
Java:
public class Producer extends Thread {
private Buffer buffer;
private int start;
public Producer(Buffer b, int s)
{
buffer = b;
start = s;
}
public void run()
{
for(int i = start; i < start+100; i++)
{
buffer.put(i);
}
}
}
Java:
public class Consumer {
private Buffer buffer;
public Consumer(Buffer b)
{
buffer = b;
}
public void run()
{
for(int i = 0; i < 100; i++)
{
int x = buffer.get();
System.out.println("gelesen: "+ x);
}
}
}
Java:
public class Buffer {
private boolean available = false;
private int data;
public synchronized void put(int x)
{
while(available)
{
try
{
wait();
}
catch(InterruptedException e)
{
}
}
data = x;
available = true;
notify();
}
public synchronized int get()
{
while(!available)
{
try
{
wait();
}
catch(InterruptedException e)
{
}
}
available = false;
notify();
return data;
}
}Kann ich hier ablage als Buffer verstehen?
Was ist hier Producer und was ist hier consumer?
Kann mir da jemand weiterhelfen?
Es währe gut, wenn ich die Aufgabe zusammen mit der Community lösen kann, ich "verlange" keine fertige Lösung, denn die hilft mir nicht beim verstehen des Prinzips.
