Threads, Peterson Algo.

[Vintner]

Hallöchen,

ich verusche zwei Threads mittels Peterson Algorithmus zu synchronisieren. Ist es möglich, mittels Konsolenausgabe zu zeigen, dass einer der Threads wartet?
So wie ich das gemacht habe funktioniert das leider nicht, die Methoden addProduct und takeProduct werden je von einem Thread in einer Schleife ausgeführt. Leider wird die System.out.println() Funktion nicht beachtet, wißt ihr was ich das falsch mache?

private boolean flag0 = false, flag1 = false;
int turn;

        public synchronized void addProduct(Product product) throws InterruptedException
        {
		flag0 = true;
		turn = 1;
		while(flag1 && (turn == 1))
		{
			System.out.println("Produzent wartet");
			wait();
		}
		stack.add(product);
		flag0 = false;
		notify();
	}
	

        public synchronized Product takeProduct() throws InterruptedException
	{
		flag1 = true;
		turn = 0;
		while(flag0 && (turn == 0))
		{
			System.out.println("Consumer wartet");
			wait();
		}
		flag1 = false;
		notify();
		return stack.poll();
	}

 

[SlaterB]

wenn keine Ausgabe erscheint ist die naheliegenste Ursache zunächst, dass die while-Schleife gar nicht durchlaufen wird..

logge wirklich alles, direkt zum Aufruf der Methode, vor der Schleife den Inhalt der Variablen usw.,
poste gegebenenfalls ein vollständiges Beispielprogramm

 

[Vintner]

Hallo SlaterB,

die while Schleife wird irgendwie nicht durchlaufen, dachte dass das wait() vielleicht irgendetwas beeinflußt.

Hier mal etwas mehr Code:

STACK-KLASSE, erstellt Stack auf den Produkte gelegt und entnommen werden sollen

import java.util.ArrayDeque;

public class Stack
{
	//Synchronisationsvariablen flag0, flag1 und turn
	private boolean flag0 = false, flag1 = false, stackSynch = true;
	int turn;
	//ArrayDeque für eine leichte fifo Handhabung
	private ArrayDeque<Product> stack;
	
	public Stack(boolean stackSynch)
	{
		stack = new ArrayDeque<Product>();
		this.stackSynch = stackSynch;
	}
	
	/*
	 * Abfrage, ob der Stack synchronisiert laufen soll
	 * @return true, wenn synchron; false, wenn asynchron
	 */
	public boolean isSynch()
	{
		if(this.stackSynch)
			return true;
		else
			return false;
	}
	
	/*
	 * Ein Produkt auf den Stapel legen
	 * Synchronisation:
	 * Thread0 will in den kritischen Abschnitt eintreten (flag0 setzen, turn = 1), das geht aber nur, 
	 * wenn sich Thread 1 nicht bereits im kA befindet (flag1 gesetzt ist).
	 * @param product Produkt mit eigener ID
	 */
	public synchronized void addProductSynch(Product product) throws InterruptedException
	{
		flag0 = true;
		turn = 1;
		while(flag1 && (turn == 1))
		{
			System.out.println("Produzent wartet");
			wait();
		}
		stack.add(product);
		System.out.println("Produkt gestapelt: ID = " + product.getId());
		flag0 = false;
		notifyAll();
	}
	
	/*
	 * Unsynchronisierte Methode um ein Produkt zu stapeln
	 * @param product das zu stapelnde Produkt
	 */
	public void addProductUnSynch(Product product) throws InterruptedException
	{
		stack.add(product);
		System.out.println("Produkt gestapelt: ID = " + product.getId());
	}
	
	/*
	 * Synchronisierte Methode für das Produkt vom Stapel entnehmen
	 * Das oberste Produkt vom Stapel entfernen.
	 * @return das oberste Produkt des Stapels
	 */
	public synchronized Product takeProductSynch() throws InterruptedException
	{
		flag1 = true;
		turn = 0;
		while(flag0 && (turn == 0))
		{
			System.out.println("Consumer wartet");
			wait();
		}
		flag1 = false;
		notifyAll();
		System.out.println("Produkt vom Stapel genommen " + stack.getFirst().getId());
		return stack.poll();
	}
	
	/*
	 * Unsynchronisierte Methode für das Produkt vom Stapel entnehmen
	 * @return das oberste Produkt des Stapels
	 */
	public Product takeProductUnSynch() throws InterruptedException
	{
		System.out.println("Produkt vom Stapel genommen " + stack.getFirst().getId());
		return stack.poll();
	}
	
	/*
	 * Gibt an, ob der Stapel Produkte enthält, oder leer
	 * @return gibt true zurück, wenn der Stapel nicht leer ist, andernfalls	
	 * wird false zurückgegeben.
	 */
	public boolean hasElements()
	{
		if(stack.size()>0)
			return true;
		else
			return false;		
	}
	
	/*
	 * Gibt die Anzahl der Elemente im Stapel wieder
	 * @return Anzahl der Elemente im Stapel
	 */
	public int size()
	{
		return stack.size();
	}
	
	/*
	 * Alle Produkte auf dem Stapel auflisten, beginnend mit dem ersten.
	 */
	public void showElements()
	{
		try
		{
			if(this.top()!=null)
			for(Product product : stack)
			{
				System.out.println("Produkt ID = " + product.getId());
			}
		}
		catch(Exception e)
		{
			System.out.println("Stapel ist leer");
		}		
	}
	
	/*
	 * Das oberste Stack-Element ausgeben
	 * @return oberstes Stack Element
	 */
	public Product top()
	{
		return stack.getFirst();
	}
}

Der Produzent (erstellt Produkte und legt sie auf den Stapel):

public class Producer extends Thread
{
	private Stack stack;
	private int amount;
	private int stackLimit;
	private int t1Sleep;
	
	public Producer(Stack stack, int amount, int stackLimit, int t1Sleep)
	{
		this.stack = stack;
		this.amount = amount;
		this.stackLimit = stackLimit;
		this.t1Sleep = t1Sleep;
	}
	
	public void run()
	{
		try
		{
			produce(amount, stackLimit);
		}
		catch(InterruptedException e)
		{
			System.out.println("Fehler: " +e);
		}
	}
	/*
	 * Arbeiter ein Produkt herstellen und es auf 
	 * den Stapel legen lassen
	 * @param amout: Anzahl herzustellender Produkte, stackLimit: Stapelbegrenzung
	 * InterruptedException durch Pausieren
	 */
	private void produce(int amount, int stackLimit) throws InterruptedException
	{
		for(int id=1; id<=amount; id++)
		{
			if(stack.size()<(stackLimit-1))
			{
				Product product = new Product(id);
				if(stack.isSynch())
					stack.addProductSynch(product);
				else
					stack.addProductUnSynch(product);
				sleep(t1Sleep);
			}
			else
				id--;
		}
	}
}

Der Consumer (nimmt Produkte vom Stapel):

public class Consumer extends Thread
{
	private Stack stack;
	private Thread t1;
	private int t2Sleep;

	public Consumer(Stack stack, Thread t1, int t2Sleep)
	{
		this.stack = stack;
		this.t1 = t1;
		this.t2Sleep = t2Sleep;
	}
	
	public void run()
	{
		try
		{
			process();
		}
		catch(NullPointerException e)
		{
			System.out.println("Fehler: " + e);
		} 
		catch (InterruptedException e)
		{
			System.out.println("Fehler: " + e);
		}
	}
	
	/*
	 * Produkt vom Stapel nehmen und weiterverarbeiten während
	 * noch was auf dem Stapel liegt oder der Produzent noch
	 * in der Fertigung ist.
	 * NullpointerException durch Stackabfrage - bei leerem Stack
	 * InterruptedException durch das Pausieren
	 */
	public void process() throws NullPointerException, InterruptedException
	{
		while(t1.isAlive() || stack.hasElements())
		{
			if(stack.hasElements())
			{
				if(stack.isSynch())
					stack.takeProductSynch();
				else
					stack.takeProductUnSynch();
				sleep(t2Sleep);
			}
		}
	}
}

Das Produkt selbst:

public class Product
{
	private int iD = 0;
	
	public Product(int iD)
	{
		this.iD = iD;
	}
	
	/*
	 * Produkt ID auslesen
	 * @param ID des Produktes
	 */
	public int getId()
	{
		return iD;
	}
}

Und zum Schluß die main-Methode:

public class ThreadDemo 
{
	//Anzahl der herzustellenden Produkte, Stapelbegrenzung, Pausenzeiten u. Synchronisation
	private static int amount = 50;
	private static int stackLimit = 10;
	private static int t1Sleep = 1;
	private static int t2Sleep = 1;
	private static boolean stackSynch = true;
	
	public static void main(String[] args)
	{
		//Einen Stapel anlegen um Produkte zu stapeln
		if(stackSynch)
			System.out.println("Synchronisation aktiv!\n");
		else
			System.out.println("Synchronisation deaktiviert!\n");
		Stack stack = new Stack(stackSynch);
		
		//Arbeiter 1 Produkte fertigen und stapeln lassen
		Thread t1 = new Producer(stack, amount, stackLimit, t1Sleep);
		//Arbeiter 2 Produkte vom Stapel nehmen lassen und weiterverarbeiten lassen
		Thread t2 = new Consumer(stack, t1, t2Sleep);
				
		//Threads starten
		t1.start();
		t2.start();
	}
}

 

[SlaterB]

ok, hätte man auch schon bei deinem ersten Code sehen können, richtig gepostet,

also:
du hast die Methoden auf synchronized gestellt, damit werden sie immer vollständig durchlaufen (falls nicht wait unterbricht),
durch die Reihenfolge des Startens, die Dauer der Methode (System.out.println) und das notify ist anscheinend gewährleistet,
dass beide immer genau abwechselnd drankommen,

dass durch 2x Besuch hintereinander ein Thread warten muss ist auch durch andere Rahmenbedingungen mehr oder weniger ausgeschlossen (dafür dann der Restcode günstig),
der Consumer kommt gar nicht erst vorbei, wenn der Stack leer ist,
der Producer kann dank jeder Menge Platz seine ganzen Elemente abladen, egal was der Consumer macht,
warum also je warten?

------

die Methoden dürfen also nicht mehr synchronzid sein, allenfalls die Einzelaufrufe wait() + notify() für sich einbetten,
dann läuft es aber immer noch nicht rund, durch bestimmten Ablauf kommt es zum Deadlock,

das wait() wartet bis ans Ende aller Tage, da musst du einen Timeout einbauen, dann ist auch das notify() nicht mehr so dringend,
ist eh unschön, verzichte auf die Java-Mittel synchronzid, wait, notify komplett, schließlich baust du genau das nach!,
warte mit Thread.sleep(100), dann sollte es zusammen mit den flags laufen

wenn die warte-Schleifen-Anzeige immer noch nicht kommt und du sie testweise erzwingen willst, dann setze die Zeit im kritischen Abschnitt durch Thread.sleep(100) hoch,
der Producer bekommt etwas Vorsprung bzw. ist schneller, damit der Stack nicht leer ist,
deine sleep-Zeiten t1Sleep/ t2Sleep sind generell zu niedrig, unter 30ms ist es fast unmessbar

 

[Vintner]

Danke, ich dachte immer dass man die gesamte Methode synchronisieren müsste. Hab den Code jetzt geändert und es klappt. Dank dir