Ausgeben welcher Thread gerade Arbeitet

[DaSt]

Servus,

in einer alten Klausuraufgabe sollte man 3 Threads gleichzeitig starten und es sollten 5000 Zufallszahlen ausgegeben werden. Zum Schluss sollte 1* "Fertig" erscheinen. Mich würde jetzt interessieren ob es möglich ist, dass hinter jeder Zufallszahl noch steht welcher der 3 Threads diese bearbeitet hat.

Mein Code sieht so aus(und liefert auch das gewünschte Ergebnis):

Thread-Klasse

public class Zufall extends Thread {

   private static int counter = 0;
   private static int counter2 = 0;

   @Override
   public void run() {

     zufall();
   }

   private static synchronized void zufall() {

     for (int i = 0; i < 5000; i++) {
       
       if (counter < 5000) {
         try {
           int rückgabe = 0;
           SecureRandom rnd = SecureRandom.getInstance("SHA1PRNG");
           rückgabe = rnd.nextInt();
           System.out.println("Nr: "+i+ "= "+rückgabe);
         } catch (NoSuchAlgorithmException e) {
           e.printStackTrace();
         }
         counter++;
       }

     }
     if(counter2<1){
       System.out.println("Fertig");
       counter2++;
     }

   }

}

main-klasse

public class main {

   public static void main(String[] args) {

     Zufall t1 = new Zufall();
     Zufall t2 = new Zufall();
     Zufall t3 = new Zufall();
     
     
     t1.start();
     t2.start();
     t3.start();
     
   }

}

Ich hätte als Ausgabe z.B. sowas in der Art:

"Nr. 355 = 65245542541 bearbeitet von t1"

falls das möglich ist.

Vielen Dank

 

[InfectedBytes]

Du kannst dafür direkt die Thread methoden wie z.b. getName() oder getId() nutzen

 

[DaSt]

danke

 

[DaSt]

War dich Woche beschäftigt und bin deswegen erst jetzt zum Testen gekommen.
Ich habe es mir folgendermaßen ausgeben lassen:

(Ich habe nur der Methode zufall() die Ausgabe erweitert)

..

          System.out.println("Nr: "+i+ "= "+rückgabe+"  Bearbetet von Thread: "+Zufall.currentThread().getName());

...

Dann kommt aber, dass die komplette Ausgabe immer von Thread 0 abgearbeitet wird.
Sollte das nicht zwischen den einzelnen Threads hin- und herwechseln?

Danke

 

[InfectedBytes]

du hast das ganze synchronisiert. Daher kann immer nur ein einziger Thread zur gleichen Zeit in deiner Zufall methode sein. Thread1 kommt nun als erstes an und durch die synchronisierung warten alle anderen Threads solange, bis er die zufall methode verlassen hat.

Du solltest dich besser nochmal in synchronisierung und threading einlesen

 

[DaSt]

Wieso funktioniert dann aber die Musterlöung, dort wurde auch die komplette Methode synchronized

public class ThreadCount extends Thread{

   private static final int max = 5000;
   private static int counter =0;
  
  
   public void run(){
    
     while(incrementIfValid());
   }
  
  
  
   private synchronized boolean incrementIfValid(){
    
     if(counter<max){
       ++counter;
       System.out.println("Nr: "+counter + " Bearbeitet von: "+ThreadCount.currentThread().getName());
       return true;
     }
     return false;
   }
  
  
  
  
  
}

 

[InfectedBytes]

Der Unterschied ist, dass deine Methode statisch ist, daher gibt es auch nur einen statischen Monitor, welcher eben nur einen einzigen Thread zulässt.

Nun zur "Musterlösung":
Hier ist die sychronisierte Methode eben nicht mehr statisch, dass führt dazu, dass das Objekt selbst (this) als Monitor genutzt wird. Daher kann immer nur ein Thread gleichzeitig auf die Methode von dieser konkreten Instanz zugreifen.

Und genau hier liegt ein anderer Fehler in der Musterlösung vor, denn dadurch sychronisiert sie effektiv nicht. Denn hier können die Threads tatsächlich parallel ausgeführt werden, allerdings wird eben unsynchron auf den counter zugegriffen werden.
++counter sieht vielleicht wie eine einzige, atomare Anweisung aus, ist es aber nicht.
Effekt wird hier der Wert von counter ein ein CPU register geholt, der Wert um eins erhöht und dann wieder zurückgeschrieben.
Da die Musterlösung den Zugriff darauf nicht sychronisiert, kann es also passieren, dass zwei Threads sich gleichzeitig den Wert holen (z.B. den Wert 0), dann erhöhen beide den Wert um eins und schreiben beide eine 1 zurück!

 

[DaSt]

Vielen Dank für deine Geduld, dann werde ich mich nochmal näher mit dem Thema befassen

 

[InfectedBytes]

Die Links können dir vielleicht helfen:
Threading allgemein
Synchronized