# Thredhandling Frage und Verständnis Problem



## mxm_d1 (13. Mrz 2022)

Hallo, in meiner Weiterbildung dreht es sich momentan viel um Thredhandling und semaphoren,
habe soweit das Prinzip verstanden, allerdings haben wir in den Übungen oft den falls das wir
in der klasse ein extend threads machen, könnte mir jemand zeigen wie es aussehen würde wenn ich
mit einem implements runnable arbeiten müsste ?

danke


----------



## mihe7 (13. Mrz 2022)

Das sieht fast genauso aus, nur dass dann eben unmittelbar Instanzen der Klasse Thread erstellt werden, denen ein Roboter-Objekt übergeben wird.

```
// statt 
// Roboter roboter = new Roboter(...);
// roboter.start();
// schreibst Du eben

Roboter roboter = new Roboter(...);
Thread th = new Thread(roboter);
th.start();
```


----------



## Oneixee5 (13. Mrz 2022)

Das steht auch in der API-Dokumentation mit Beispiel: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Thread.html


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> Das sieht fast genauso aus, nur dass dann eben unmittelbar Instanzen der Klasse Thread erstellt werden, denen ein Roboter-Objekt übergeben wird.
> 
> ```
> // statt
> ...


ah okay danke, und in der roboter klasse muss ich bloß das extends in die impliment methode ändern? der rest bleibt ?


----------



## mihe7 (13. Mrz 2022)

Ja, Roboter muss Runnable implementieren. Und was den Rest betrifft: im Grundsatz ja, aber natürlich wirst Du da ein wenig anpassen müssen. Schau mal, ob Du es hinbekommst.


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> Ja, Roboter muss Runnable implementieren. Und was den Rest betrifft: im Grundsatz ja, aber natürlich wirst Du da ein wenig anpassen müssen. Schau mal, ob Du es hinbekommst.


irgentwie klappt das nicht, kann ich die sleep methode z.b. dann nicht mehr so benutzen ?
Im normalfall benutzen wir schulisch die Extend methode momentan, habe aber etwas angst falls in der Prüfung morgen doch
der andere Fall dran kommt


----------



## mihe7 (13. Mrz 2022)

mxm_d1 hat gesagt.:


> irgentwie klappt das nicht, kann ich die sleep methode z.b. dann nicht mehr so benutzen ?


sleep ist eine statische Methode der Klasse Thread, sollte also immer via `Thread.sleep(...)`aufgerufen werden, selbst wenn man von Thread ableitet.


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> sleep ist eine statische Methode der Klasse Thread, sollte also immer via `Thread.sleep(...)`aufgerufen werden, selbst wenn man von Thread ableitet.


Ahh macht sinn 
Könntest du mir bei dem umschreiben für die Runnable Methode helfen ?


----------



## mihe7 (13. Mrz 2022)

Jetzt habe ich mir den Code mal näher angesehen, da sind ein paar Fallstricke eingebaut, weil der Thread-Name als Roboter-Name verwendet wurde  


```
import java.io.*;
import java.util.concurrent.Semaphore;

class Roboter implements Runnable {

    Semaphore sem;
    private final String name;

    public Roboter(Semaphore sem,int i){
        name = "Hans" +i; //KIRobotron-Mega<i>
        this.sem = sem;
    }
    
    public String getName() { return name; }

    public void run(){      //hier steht, was jeder Roboter machen soll, wird für Threds  benötigt
                            //beinhaltet den Code der von unserem Thred ausgeführt werden soll


        for(int lauf = 1; lauf <=3; lauf++){
            try{

                sem.acquire();

                BufferedWriter aus = new BufferedWriter(new FileWriter("stapelzeit.txt",true));

                int zeit =  (int)((Math.random() * 26)+30);   //26 zufällige Werte zwischen
                // double-Wert zwischn 0< ... <1              //30 und 55
                synchronized (aus){
                    aus.write("Kennung: " +  this.getName() + " Zeit: " + zeit + " Sekunden");
                    aus.newLine();
                    aus.close();
                    System.out.println("Kennung: " +  this.getName() + " Zeit: " + zeit + " Sekunden");
                    Thread.sleep(zeit*10);
                }
            }
            catch(IOException ex){}
            catch (InterruptedException ex) {}
            finally {
                sem.release();
            }
        }
    }
}
```


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> Jetzt habe ich mir den Code mal näher angesehen, da sind ein paar Fallstricke eingebaut, weil der Thread-Name als Roboter-Name verwendet wurde
> 
> 
> ```
> ...


ah okay, erkenne die unterschiede, danke  

rFeld_ rob  = new Roboter(sem,i);
Thread th = new Thread(rob);
th.start();

mein wohl letztes problem ist das ding mit der Schleife bzw dem array feld, kann ich das rFeld ist der RoboterStapelTestKlasse so benutzen ?_


----------



## mihe7 (13. Mrz 2022)

Probiers aus


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> Probiers aus


rFeld_ = new Roboter(sem,i);
Thread th = new Thread(rFeld);
th.start();

habe mir die Lösung zusammen gebastelt, sie funktioniert.
Ist es aber sinnvoll es so zu schreiben ? 

rFeld = new Roboter(sem,i);
Thread th = new Thread(rFeld);
th.start();_


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> Probiers aus


oh sory ich meine diese hier 

rFeld_ = new Roboter(sem,i);
Thread th = new Thread(rFeld);
th.start();_


----------



## mihe7 (13. Mrz 2022)

mxm_d1 hat gesagt.:


> Ist es aber sinnvoll es so zu schreiben ?


Das kann man pauschal nicht sagen. Im Prinzip brauchst Du nicht einmal ein Array, weil Du ja nichts mehr damit machst. Es kann also sinnvoll sein, die Threads in einem Array abzulegen, es kann sinnvoll sein, die Roboter in einem Array abzulegen, es kann sinnvoll sein, sich beides zu merken usw. 

Das

```
for (int i = 0; i < anzahl; i++) { 
            new Thread(new Roboter(sem,i)).start();
        }
```
würde genauso funktionieren.

Wenn Du allerdings z. B. auf die Beendigung warten möchtest, macht es Sinn, sich die erzeugten Threads zu merken:

```
Thread[] threads = new Thread[anzahl];
        for (int i = 0; i < threads.length; i++) { 
            threads[i] = new Thread(new Roboter(sem,i));
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }
```
Und wenn Du dann noch Informationen vom Roboter haben willst, solltest Du Dir diese natürlich auch merken:

```
Thread[] threads = new Thread[anzahl];
        Roboter[] robots = new Roboter[anzahl];
        for (int i = 0; i < threads.length; i++) { 
            robots[i] = new Roboter(sem, i);
            threads[i] = new Thread(robots[i]);
            threads[i].start();
        }

        for (int i = 0; i < threads.length; i++) {          
            threads[i].join();
            System.out.println("Roboter " + robots[i].getName() + " ist fertig.");
        }
```


----------



## mxm_d1 (13. Mrz 2022)

mihe7 hat gesagt.:


> Das kann man pauschal nicht sagen. Im Prinzip brauchst Du nicht einmal ein Array, weil Du ja nichts mehr damit machst. Es kann also sinnvoll sein, die Threads in einem Array abzulegen, es kann sinnvoll sein, die Roboter in einem Array abzulegen, es kann sinnvoll sein, sich beides zu merken usw.
> 
> Das
> 
> ...


danke dir hast mir sehr geholfen


----------

