Aufgabe(Threads) richtig verstanden/implementiert

[javac-]

Hallo,

ich weiss nicht so recht ob ich folgende Aufgabe richtig verstanden/implementiert habe:

"Schreiben Sie ein Programm, dass mit 100 Threads gleichzeitig bis 100 zählt. Verwenden Sie hierfür die untenstehende Klasse "Counter". Zur Implementierung der Zugriffsbeschränkung auf die gemeinsame Variable nehmen Sie bitte das aus der Vorlesung bekannte Monitor-Konzept(Stichwort synchronized)"

Die Methode „increase()“ soll zusätzlich zu dem Hochzählen der Varibale „count“ den Zählerstand und den Thread, der die Methode aufgerufen hat, ausgeben.

Ich habs folgendermaßen implementiert:

Klasse: Counter

public class Counter {
   private int count =0;
  
  
   //Methode zum Hochzählen der Variabeln Count, sowie Ausgabe des akt. Threads
   public void increase(){
     this.count++;
     System.out.println(Thread.currentThread().getName() +" "+ this.count);
   }
     
   //Getter,Setter
   public int getCount() {
     return count;
   }

   public void setCount(int count) {
     this.count = count;
   }
   }

ThreadKlasse

public class ThreadClass extends Thread{
 
   private int end;//Soweit soll der jeweilige Thread hochzählen
   private Counter counter = new Counter();
  
  
   //Konstruktor
   public ThreadClass(int end){
     this.end=end;
   }
  
  
   //Run-Methode
   public void run(){
     hochzählen();
   }

  
   public void hochzählen(){
    
     for(int i=0; i<this.end; i++){
      
       synchronized(this.counter){
         this.counter.increase();
         if(i==this.end-1){
           System.out.println(Thread.currentThread().getName()+" ist fertig");
         }
       }
     }
   }

   //Getter,Setter
   public int getEnd() {
     return end;
   }
   public void setEnd(int end) {
     this.end = end;
   }

Main

public static void main(String[] args) {
   
     //In einer For-Schleife mit 100 Threads auf 100 zählen
     for(int i=0; i<100; i++){
       ThreadClass t1 = new ThreadClass(100);
       t1.start();
     }    
   }

 

[fhoffmann]

Ich verstehe die Aufgabe so, dass du eine (!) Instanz der Klasse Counter erzeugst und 100 Threads erzeugst, die in dieser einen Instanz jeweils einmal (!) increase() aufrufen. Wenn alles gut geht, wurde in der einen Instanz von Counter dann count auf 100 gesetzt. Verantwortlich dafür, dass alles gut geht, ist die Methode increase().

 

[Phtevenz]

Die Aufgabe sieht aus als könnte sie sehr unterschiedlich ausgelegt werden. Sollst du denn etwas bestimmtes zeigen? Laufzeitmessungen, oder Nicht-Determinismus(unterschiedliche Ausgaben bei mehreren Durchläufen) oder ist es eine Übung zu gegenseitigem Ausschluss bei Threads (mutex etc)?

 

[javac-]

Es geht nur um Threads.. das ist die erste Aufgabe zu dem Thema(mit Threads haben wir erst letzten Freitag angefangen).

 

[mrBrown]

Ich versteh's auch als 100 Threads, eine Counter-Instanz (ob jeder Thread 100 hochzählen oder alle zusammen 100 ist für mich nicht ersichtlich...)

Unabhängig von der Aufgabenstellung sollte man aber Thread nicht extenden, sondern runnable implementieren
Außerdem macht synchronized so keinen Sinn, und an überschriebene Methoden gehört @Override.

 

[javac-]

Das mit dem runnable implementieren haben wir(bisher) noch nicht durchgenommen.

 

[mrBrown]

Interfaces hattet ihr aber schon?
Habt ihr irgendeine Vorgabe, wie ihr Threads erstellen sollt?

 

[Phtevenz]

ja die Frage die jetzt noch zu klären ist, wäre ob die Threads zusammen den counter hochzählen oder ob jeder Thread seinen eigenen counter hat.

So am Rande, warum sollte man Threads nicht extenden sondern als Interface implementieren?

 

[javac-]

Interfaces hattet ihr aber schon?
Habt ihr irgendeine Vorgabe, wie ihr Threads erstellen sollt?

Ja interfaces hatten wir. Nein wir haben keine exakte Vorgabe wie wir Threads erstellen müssen. Wie oben schon erwähnt haben wir mit Threads letzten Freitag begonnen und uns wurde es eben so gezeigt - also ...extends Thread

 

[mrBrown]

So am Rande, warum sollte man Threads nicht extenden sondern als Interface implementieren?

Weil implementieren der schönere, sauberere Weg für sowas ist Man will schließlich nicht Thread um Funktionalität erweitern, sondern irgendeinen Thread nur eine Methode ausführen lassen.

Ja interfaces hatten wir. Nein wir haben keine exakte Vorgabe wie wir Threads erstellen müssen. Wie oben schon erwähnt haben wir mit Threads letzten Freitag begonnen und uns wurde es eben so gezeigt - also ...extends Thread

Dann sieh Runnable implementieren als das gelernte anwenden

 

[Phtevenz]

ok hier haben alle Threads die gleiche Zählvariable (in der Angabe stand was von synchronized, draus schließe ich auch eine gemeinsam genutzte Variable)

public class MainClass {
    public static void main(String[] args) {
        for (int i=0;i<100;++i){
            IncrementThread t = new IncrementThread(i);
            t.start();
        }
    }

}

public class IncrementThread extends Thread{
    int id;
    static int counter=0;

    public IncrementThread(int id){
        super();
        this.id=id;
    }

    @Override
    public void run(){
        System.out.println("Hier ist Thread " + this.id);
    }

    synchronized void increase(){
        ++counter;
    }

    synchronized int getCount(){
        return counter;
    }


}

edit: ohne gewähr. ich bin selbst nicht so ganz fit mit der materie. das hochzählen und ausgeben der variable sollte noch implementiert werden

 

[mrBrown]

public class IncrementThread extends Thread{
    int id;
    static int counter=0;

    public IncrementThread(int id){
        super();
        this.id=id;
    }

    @Override
    public void run(){
        System.out.println("Hier ist Thread " + this.id);
    }

    synchronized void increase(){
        ++counter;
    }

    synchronized int getCount(){
        return counter;
    }


}

Da gibts weder eine gemeinsam genutzte Variable, noch macht synchronized an den Stellen Sinn, die Methoden innerhalb des Threads werden schließlich nur von einem Thread -sich selbst - aufgerufen

 

[Phtevenz]

ist der counter nicht gemeinsam benutzt?

nun dann muss ich in der main methode das synchronized setzen richtig?

 

[mrBrown]

Oh, doch, counter wird gemeinsam benutzt, hab das static übersehen. Würd ich da aber auch nicht benutzen.
In der main bringt es nichts, irgendwas synchronized zu setzten, in dem Object wird ja auch nichts aufgerufen.

In dem Fall des statischen Counters müsste man noch zusätzlich ein Objekt zur Synchronisierung einführen...Deshalb wäre es da Sinnvoller, ein Counter-Objekt wie im Ursprungspost zu verwenden, in diesem kann man dann Methoden mit synchronized kennzeichnen (bzw dieses zum Locken nutzen), dann funktionierts.

 

[Phtevenz]

public class IncrementThread implements Runnable{
    int id;
    static Counter c=new Counter();

    public IncrementThread(int id){
        super();
        this.id=id;
    }

    public void run(){

        synchronized (c){
            c.increase();
            System.out.println("Hier Thread " + id + " counter hat den Wert " + c.getCount());
        }

    }

    public static class Counter {
        int count =0;

        void increase(){
            count++;
        }
        int getCount(){
            return count;
        }
    }
}

trifft es das hier besser?

 

[mrBrown]

Ja, wobei ich static immer noch vermeiden würde, lieber eine Instanz im Konstruktor übergeben.
(@Override noch dran)

 

[javac-]

public class IncrementThread implements Runnable{
    int id;
    static Counter c=new Counter();

    public IncrementThread(int id){
        super();
        this.id=id;
    }

    public void run(){

        synchronized (c){
            c.increase();
            System.out.println("Hier Thread " + id + " counter hat den Wert " + c.getCount());
        }

    }

    public static class Counter {
        int count =0;

        void increase(){
            count++;
        }
        int getCount(){
            return count;
        }
    }
}

Ist der einzige Unterschied beim erstellen eines Threads mit Runnable im Gegensatz zu extends , dass nicht Thread extended wird, sondern Runnable implementiert?

 

[Phtevenz]

neuer versuch. jetzt haben die threads auch keine id mehr

public class IncrementThread implements Runnable{
    int id;
    Counter c;

    public IncrementThread(Counter count){
        super();
        this.c = count;
    }
        public void run(){

        synchronized (c){
            System.out.println("Hier Thread " + id + " counter hat den Wert " + c.getCount());
            c.increase();
        }

    }

    public class Counter {
        int count =0;

        protected void increase(){
            count++;
        }
        protected int getCount(){
            return count;
        }
    }
}

public class MainClass {
    public static void main(String[] args) {
        IncrementThread.Counter c =IncrementThread.new Counter();
        for (int i=0;i<100;++i){
            IncrementThread t = new IncrementThread(c);
            t.run();
        }
    }

}

den Counter erstellen in der Main klappt nicht. Mache ich etwas falsch? "IncrementThread Cannot be resolved to a variable"

 

[javac-]

so auch nicht??

Counter c1 = new Counter(); 
IncrementThread t = new IncrementThread(c1);

 

[mrBrown]

Ist der einzige Unterschied beim erstellen eines Threads mit Runnable im Gegensatz zu extends , dass nicht Thread extended wird, sondern Runnable implementiert?

Ja, und dem Thread übergibt man das Runnable dann.

den Counter erstellen in der Main klappt nicht. Mache ich etwas falsch? "IncrementThread Cannot be resolved to a variable"

Ja, die innere Klasse gehört immer zu einem Objekt, um die so anzusprechen müsse sie static sein. Lager Counter einfach in eine eigene Klasse aus oder mach sie static.

 

[Phtevenz]

Ja jetzt geht es.

public class IncrementThread implements Runnable{
    int id;
    Counter c;

    public IncrementThread(Counter count){
        this.c = count;
    }
        public void run(){
            System.out.println("counter an der stelle " + c +"  hat den Wert " + c.getCount());
            c.increase();
    }


}

public class Counter {
    int count =0;
    public void increase(){
        count++;
    }
    public int getCount(){
        return count;
    }
}

aber hier ist jetzt kein synchronized. das brauche ich anscheinend auch nicht. der counter ist aber laut speicheradresse wirklich bei allen der selbe? ich dachte ohne synchronized block um den counter würden hier seltsame ergebnisse kommen

 

[mrBrown]

Doch, da muss trotzdem synchronized an die passende Stelle. ++ ist keine atomare Operation, 2 Threads könnten gleichzeitig erhöhen, was zu insgesamt einem Increment führen würde

 

[Phtevenz]

dann sind meine anweisungen insgesamt wohl einfach nur sehr "schnell"?
ich habe jetzt öfter 1000 threads erstellt und konnte nichts ungewöhnliches feststellen.

noch eine andere frage: mache ich durch den synchronized block um den counter nicht das ganze multithreading sinnlos? ich meine da wird ja nichts parallel ausgeführt oder täusche ich mich da

 

[Flown]

mache ich durch den synchronized block um den counter nicht das ganze multithreading sinnlos?

Ja, aber Ziel der Übung ist es zu zeigen, dass der 13. Thread auch den Zähler auf 8 setzen kann, weil er "schneller" an der Reihe war als der der 8. Thread.

ich meine da wird ja nichts parallel ausgeführt oder täusche ich mich da

Doch es wird parallel gezählt, die Threads sollten aber höflich warten, bis sie an der Reihe sind. Versuch doch mal ohne Synchronisation den Endwert zum Schluss auszugeben (musst du eventuell ein paar mal ausführen, damit du den Glitch siehst, da count++ keine atomare Operation ist!)

 

[InfectedBytes]

Es passiert halt nicht viel, eben nur eine einfache Inkrementation, daher kann es gut sein, dass dein Thread sofort durchläuft, bevor der nächste überhaupt startklar ist. Daher hast du das Problem bisher noch nicht feststellen können. Aber wenn du es oft genug probierst, wirst du vermutlich irgendwann auch den Problemfall zu sehen bekommen.
Wenn einmal die Komplexität steigt, wird es auch immer wahrscheinlicher, dass sich zwei Threads in die Quere kommen können. Wenn du z.b. eben viel mehr als nur eine einfach Inkrementation machst, wirst du sehr schnell die Probleme sehen

 

[Phtevenz]

du hast recht. einige zahlen kommen doppelt vor.

gibt es denn atomare operationen irgendeiner art? um solche müssten dann keine synchronized blöcke gesetzt werden stimmt das?

 

[mrBrown]

gibt zB AtomicInteger (mit dem man ohne synchronized incrementieren kann)

 

[Phtevenz]

wow. vielen Dank, vieles wusste ich nicht vorher. habe zwar den thread nicht erstellt aber ich hab mich trotzdem mal eingemischt