Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- parallelism:start [2025/01/07 11:04] – [Nebenläufige Prozesse] Martin Pabst
+++ parallelism:start [2025/03/09 07:53] (aktuell) – [Beispiel 1: Überschreiben der run()-Methode] Martin Pabst
@@ Zeile 61: / Zeile 61: @@
+===== Die Methode join =====
+<WRAP center round info 60%>
+Ruft man während der Abarbeitung eines Threads (im folgenden: "Thread 1") die Methode ''join'' eines **anderen** Threads (im folgenden: "Thread 2") auf, so wartet Thread 1 so lange, bis Thread 2 beendet ist. Erst dann fährt Thread 1 mit der nächsten Anweisung fort. \\ \\
+**Wichtiges Detail:** \\
+Das "Warten" von Thread 1 geschieht nicht **aktiv**, indem in einer Wiederholung immer wieder überprüft wird, ob Thread 2 schon beendet ist, sondern **passiv**, d.h. der für Thread 1 reservierte Prozessorkern steht in dieser Zeit für andere Threads zur Verfügung:
+</WRAP>
+==== Beispiel 2: Nutzung von Thread.join ====
+<HTML>
+<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Threads1a'}">
+<script type="text/plain" title="Hauptprogramm.java">
+SystemTools.setSpeed(8);
+ArrayList<Thread> threads = new ArrayList<>();
+for (int i = 0; i < 10; i++) {
+   Thread t = new MyThread("Thread " + i);
+   threads.add(t);
+   t.start();
+}
+for(Thread t: threads){
+   t.join();
+}
+println("Alle fertig!", Color.lightgreen);
+class MyThread extends Thread {
+   public void run() {
+      int i = 0;
+      while (i < 10) {
+         i++;
+         println(this.getName() + " counts:  " + i );
+      }
+   }
+}
+</script>
+</div>
+</HTML>
 ==== Beispiel 2: Eigene Klasse, die Runnable implementiert ====
 {{ :parallelism:thread-class-diagram_myrunnable.svg |}}
@@ Zeile 107: / Zeile 152: @@
 Lambda functions sind ein Ersatz für die in vielen anderen Programmiersprachen verfügbaren **closures**, unterscheiden sich aber in einem wesentlichen Punkt von diesen: Wird eine **außerhalb** der lambda function/closure deklarierte Variable **innerhalb** der lambda function/closure genutzt, so wird
   * im Falle der lambda function ihr Wert zum Zeitpunkt des Starts der Funktion übergeben während
-  * im Falle der closures eine Referenz übergeben wird.
+  * im Falle der closure eine Referenz übergeben wird.
 Bei letzteren kann daher von verschiedenen closures und von außerhalb auf **die identische Variable** zugegriffen werden, während bei ersteren jede lambda function ihre eigene Kopie der Variable erhält und nur auf diese zugreifen kann.
 </WRAP>