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 :

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148

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

mal ne kurze zwischenfrage zu folgendem Abschnitt:

Code :

1 2 3 4 5 6 7 8 9

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?

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

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

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

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!

Zitat von 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

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

Code :

1 2 3 4 5 6

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

oder so:

Code :

1 2 3 4 5

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