Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- parallelism:start [2025/01/07 11:04] – [Nebenläufige Prozesse] Martin Pabst
+++ parallelism:start [2025/05/02 08:05] (aktuell) – [Aufgabe 1: Arbeitsteiliges Abarbeiten einer Aufgabe durch mehrere Threads] Martin Pabst
@@ Zeile 98: / Zeile 98: @@
-==== Für Interessierte: Implementierung eines Interfaces durch eine Lambda-Function ====
+===== 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 3: 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>
+==== Aufgabe 1: Arbeitsteiliges Abarbeiten einer Aufgabe durch mehrere Threads ====
+<WRAP center round todo 80%>
+Im folgenden Programm wird die Summe aller Elemente eines Arrays ermittelt und ausgegeben. Die Abarbeitung dieser Aufgabe erfolgt in einem einzigen Thread. \\ \\
+Schreiben Sie das Programm so um, dass 10 nebenläufige Threads je 1/10 der Werte addieren und nach Abarbeitung aller 10 Threads die Teilsummen zu einer Gesamtsumme zusammengefasst werden.
+</WRAP>
+<WRAP center round tip 80%>
+**Wichtige Info zu dieser Aufgabe:** \\
+Javascript-Programme im Browser unterliegen der Einschränkung, dass sie nur von einem Prozessor-Thread ausgeführt werden können. Die Online-IDE simuliert mehrere Threads durch einen eigenen Scheduler, der schnell zwischen den Threads "umschaltet". Dies bringt aber natürlich keinen Geschwindigkeitsvorteil. \\
+Startet man in einer "echten" Java Runtime Engine mehrere Threads, so werden sie auf mehrere Prozessorkerne verteilt und erzielen damit i.d.R. einen erheblichen Geschwindigkeitsvorteil gegenüber einem einzelnen Thread.
+</WRAP>
+<HTML>
+<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'ThreadsArbeitsteiligVorlage'}">
+<script type="text/plain" title="Hauptprogramm.java">
+int[] werte = new int[1000];
+for (int i = 0; i < werte.length; i++) {
+   werte[i] = Random.randint(-1000, 1000);
+}
+println(new ArrayTool().summe(werte));
+class ArrayTool {
+   int summe(int[] werte) {
+      int summe = 0;
+      for (int i = 0; i < werte.length; i++) {
+         summe += werte[i];
+      }
+      return summe;
+   }
+}
+</script>
+</div>
+</HTML>
+[[.arbeitsteiligLoesung:start|Lösung]]
+==== Für Interessierte: Implementierung eines Interfaces durch eine Lambda-Function (nicht klausurrelevant) ====
 <WRAP center round info 80%>
 Besitzt ein Interface nur eine einzige Methode, so nennt man es **functional interface**. Das Interface ''Runnable'' ist ein Beispiel dafür. \\
@@ Zeile 107: / Zeile 195: @@
 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>