Wait, notify, notifyAll - ich hänge bei meiner Aufgabe :-(

[nighty86]

Hallo erstmal

Ich arbeite hier an einem kleinen Programm (BoundedCounter), welcher einen Zähler hat, mit dem ich anhand von Threads hoch und runter zähle. Im Konstruktor geb ich dann ein Maximum und Minimum an...

Hier erstmal der Code :

package fopt.assignment1;



public class BoundedCounter 
{

		public static void main(String[] args)
		{
			BoundedCounter counterX = new BoundedCounter(0, 5);

			for(int i = 1; i <=3; i++)
			{
				new up(counterX);
				new up(counterX);
				new up(counterX);
				new down(counterX);
				new down(counterX);
				new down(counterX);
			}
			
		}



	
	private int zaehler, MaxWert, MinWert;
	public BoundedCounter(int MinWert, int MaxWert)
	{
	if (MinWert>MaxWert || MinWert == MaxWert)
		throw new IllegalArgumentException();
	this.MaxWert = MaxWert;
	this.MinWert = MinWert;
	this.zaehler = MinWert;
	}
	
	public synchronized void up()
	{
		while (zaehler == MaxWert)
			try
		{
			wait();
		}
		catch(InterruptedException e)
		{		
		}
		while((zaehler < MaxWert))
		{
			zaehler++;
			System.out.print(" ");
			System.out.print(get());
		}
		notifyAll();
		

			
		}
	
	public int get()
	{
		return zaehler;
	}
	
	
	public synchronized void down()
	{
		while (zaehler == MinWert)
			try
		{
			wait();
		}
		catch(InterruptedException e)
		{		
		}
		while((zaehler > MinWert))
		{		
			zaehler--;
			System.out.print(" ");
			System.out.print(get());
			
		}
		notifyAll();
		
	}

	public int getZaehler() {
		return zaehler;
	}

	public void setZaehler(int zaehler) {
		this.zaehler = zaehler;
	}

	public int getMaxWert() {
		return MaxWert;
	}

	public void setMaxWert(int maxWert) {
		MaxWert = maxWert;
	}

	public int getMinWert() {
		return MinWert;
	}

	public void setMinWert(int minWert) {
		MinWert = minWert;
	}
}
	
class up extends Thread
	{
		private BoundedCounter counter;
		public up(BoundedCounter counter)
		{
			
			this.counter = counter;
			start();
		}
	
		

		public void run()
		{		
			counter.up();				
		}
		
		
	}

	class down extends Thread
	{
		private BoundedCounter counter;
		public down(BoundedCounter counter)
		{
			
			this.counter = counter;
			start();
		}
		

		public void run()
		{
			counter.down();		
		}
		
		
	}

Scheint auch richtig zu funktionieren, jedoch krieg ich beim Bewertungssystem folgendes :

Unit Test - Test des korrekten Inkrementierens bzw. Dekrementierens
Dieser Testabschnitt prüft, ob sich die Komponente beim Inkrementieren des Zählwertes durch die Methode up() bzw. beim Dekrementieren des Zählwertes durch die Methode down() korrekt verhält. Als Basis für diesen Testabschnitt diente ein Minimum von 0 und ein Maximum von 5.
Beschreibung Unit-Test: get() liefert korrekten Wert nach einmaliger Erhöhung des Z&aumlhlers (vom Minimum ausgehend).
Testaufruf: m.get();

Fehler während Ausführung:
# Prüfung Rückgabewert fehlgeschlagen (erwartet: 1, zurückgegegeben: 5)!
Liveness Test Fehlgeschlagen: Ein oder mehrere Threads waren am Ende der Sequenz noch aktiv.
Mögliche Ursache: Thread verklemmt (Deadlock), Endlosschleife oder wait() ohne notify()

Hat da vielleicht jemand eine Idee? Und kann mir vielleicht erklären was ich falsch gemacht habe? Und warum das falsch ist? Ich finde es grad nämlich garnicht...

Danke erstmal im voraus

 

[Tsunamii]

mal ne kurze zwischenfrage zu folgendem Abschnitt:

            for(int i = 1; i <=3; i++)
            {
                new up(counterX);
                new up(counterX);
                new up(counterX);
                new down(counterX);
                new down(counterX);
                new down(counterX);
            }

Ist es beabsichtigt, dass insgesamt 9 Threads zum hochzählen und 9 zum runterzählen erstellt werden?

 

[nighty86]

In der Aufgabenstellung steht zumindest, dass ein Objekt der Klasse "BoundedCounter" von mehreren Threads gleichzeitig benutzt wird, es eben Up- und Downthreads geben soll, wobei die Up und DownThreads jeweils N-Mal erhöht und erniedrigt werden. Von jeder Thread-Sorte soll es jeweils 3 geben und gestartet werden

 

[nighty86]

Es funktioniert jetzt. Ich hatte einen richtig dämlichen Fehler drin.

 public synchronized void down()
    {
        if (zaehler == MinWert)
            try
        {
            wait();
        }
        catch(InterruptedException e)
        {       
        }
        while((zaehler > MinWert))
        {       
            zaehler--;
            System.out.print(" ");
            System.out.print(get());
            
        }
        notifyAll();

So müssen die up und down Methoden aussehen. Also, anstatt while muss ich if nutzen.
Außerdem muss die get() Methode synchronized sein...
Danke aber nochmal!

 

[Tsunamii]

In der Aufgabenstellung steht zumindest, dass ein Objekt der Klasse "BoundedCounter" von mehreren Threads gleichzeitig benutzt wird, es eben Up- und Downthreads geben soll, wobei die Up und DownThreads jeweils N-Mal erhöht und erniedrigt werden. Von jeder Thread-Sorte soll es jeweils 3 geben und gestartet werden

ok wenn du von jeder Sorte 3 haben willst dann müsstest du es aber entweder so:

                new up(counterX);
                new up(counterX);
                new up(counterX);
                new down(counterX);
                new down(counterX);
                new down(counterX);

oder so:

            for(int i = 1; i <=3; i++)
            {
                new up(counterX);
                new down(counterX);
            }