Informatik 12/13 (G9)

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
====== Nebenläufige Prozesse ======
<WRAP center round info 80%>
  * Da mit steigender Taktfrequenz von Mikroprozessoren ihre Abwärme zunimmt, stößt die Technik hier an eine Grenze, die nur überwunden werden kann, indem viele Prozessorkerne gleichzeitig an einer Aufgabe arbeiten.
  * Von modernen Betriebssystemen wird erwartet, dass sie es ermöglichen, sehr viele Prozesse (meist mehr als Prozessorkerne verfügbar sind) gleichzeitig ablaufen zu lassen.

Welche Herausforderungen dies in der Softwartechnik zur Folge hat und wie die auftretenden Probleme gelöst werden können, erfahren Sie in diesem Kapitel. \\ \\ 
**Unterkapitel:**
  * [[parallelism:monitor:start|Wechselseitiger Ausschluss]]
  * [[parallelism:producerconsumer:start|Erzeuger-Verbraucher-Probleme]]
  * [[parallelism:deadlocks:start|Deadlocks (Verklemmungen)]]
</WRAP>


===== Begriffe =====
<WRAP center round info 80%>
  * Ein laufendes Programm zusammen mit dem ihm gerade zugeordneten Ressourcen (z.B. Speicherbereiche, offene Dateien, Netzwerkverbindungen) bildet einen **Prozess** (engl.: **process**).
  * Innerhalb eines Prozesses gibt es ein- oder mehrere **nebenläufig** (parallel, engl.: **concurrently**) laufende **Ausführungsstränge** (engl.: **Threads**), die die Befehle des Programms abarbeiten. 
  * Sind mehrere Prozessorkerne vorhanden, so können Threads **gleichzeitig** ausgeführt werden. Nebenläufigkeit liegt aber auch vor, wenn das Betriebssystem dafür sorgt, dass ein Prozessor die Anweisungen mehrerer Threads abwechselnd ausführt (z.B. 10 Anweisungen des ersten Threads, dann 10 des zweiten, dann 10 des ersten usw.). 
</WRAP>

===== Threads in Java =====
<WRAP center round info 80%>
Jedes Objekt der Klasse ''Thread'' besitzt eine Methode ''run'', die dann in einem neuen Thread ausgeführt wird, wenn dieser durch Aufruf der Methode ''start'' gestartet wird. \\ \\ 
Um Code in der Methode ''run'' unterzubringen, gibt es zwei Möglichkeiten:
  * Wir schreiben eine Unterklasse von ''Thread'' und überschreiben die Methode ''run''.
  * Wir schreiben eine Klasse (z.B. ''MyRunnable''), die das Interface ''Runnable'' implementiert und damit verpflichtet ist, eine Methode ''run'' zu besitzen. Beim Instanzieren des Thread-Objekts übergeben wir ihm ein ''MyRunnable''-Objekt. 
</WRAP>


==== Beispiel 1: Überschreiben der run()-Methode ====
{{ :parallelism:thread-class-diagram.svg |}}

<HTML>

<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Threads1'}">

<script type="text/plain" title="Hauptprogramm.java">
SystemTools.setSpeed(8);
for (int i = 0; i < 10; i++) {
   new MyThread("Thread " + i).start();
}

while (true);

class MyThread extends Thread {

   public void run() {
      int i = 0;
      while (i < 10) {
         i++;
         
         println(this.getName() + " counts:  " + i );
         
      }
   }
}
</script>

</div>
</HTML>


===== 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 |}}
<HTML>

<div class="java-online" style="height: 600px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Threads2'}">

<script type="text/plain" title="Hauptprogramm.java">
SystemTools.setSpeed(8);
for (int i = 0; i < 10; i++) {
   Thread t = new Thread(new MyRunnable("Thread " + i));
   t.start();
}

while (true);

class MyRunnable implements Runnable {
   
   String name;

   MyRunnable(String name) {
      this.name = name;
   }

   public void run() {
      int i = 0;
      while (i < 10) {
         i++;
         println(this.name + " counts:  " + i);
      }
   }
}
</script>

</div>
</HTML>


==== Für Interessierte: Implementierung eines Interfaces durch eine Lambda-Function ====
<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. \\ 
An jeder Stelle, an der ein Objekt einer Klasse erwartet wird, die ein functional interface implementiert, kann stattdessen eine Kurzform verwendet werden, die man **lambda function** nennt. Sie sieht so aus:
<code java>
(parameter 1, ..., parameter n) -> { Anweisungen }
</code>
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 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>


<HTML>

<div class="java-online" style="height: 400px; width: 100%" data-java-online="{'withBottomPanel': false, 'id': 'Threads3'}">

<script type="text/plain" title="Hauptprogramm.java">
SystemTools.setSpeed(8);
for (int i = 0; i < 10; i++) {
   String name = "Thread " + i;
   Thread t = new Thread(() -> {
         for (int j = 0; j < 10; j++) {
            println(name + " counts: " + j);
         }
      });
   t.start();
}

while (true);

</script>

</div>
</HTML>