3.2.11.2 Aktives Warten

[gesichtete Version]

Version vom 3. November 2013, 15:40 Uhr

{{#index:Aktives Warten|Warten, aktiv|Geschäftiges Warten|Busy Waiting}} Aktives Warten, manchmal auch als Geschäftiges Warten oder auf Englisch Busy Waiting bezeichnet, ist eine recht einfache Technik, um Prozesse oder Threads zu Synchronisieren.

Hinweis

Findest du heraus, welchen großen Nachteil aktives Warten besitzt? Lies' mal weiter, wir kommen ganz am Ende dieser Seite auf diese Frage zurück.

Definition: Aktives Warten

Definition

{{#index:Sperrkennzeichen|Sperrvariable|Polling}} Unter aktivem Warten versteht man nach Mandl 2013 das ständige Abfragen eines Sperrkennzeichens am Eingang eines kritischen Abschnitts.

Die Technik des ständigen Abfragens ist in der Informatik auch als Polling bekannt. Das genannte Sperrkennzeichen kann eine von mehreren Prozessen oder Threads gemeinsam genutze Variable sein, man spricht dann von einer Sperrvariablen. Das folgende Beispiel geht darauf ein.

Beispiel für aktives Warten

Der Code des bereits bekannten Beispiels zu kritischen Abschnitten wird um eine (globale) Sperrvariable erweitert, beide Threads haben damit Zugriff auf diese Variable:

Code

static int lock = 0;

Besitzt lock den Wert Null, so definiert man, dass sich aktuell kein Prozess oder Thread in seinem kritischen Abschnitt befindet. Der kritische Abschnitt darf also betreten werden, dabei muss lock auf Eins gesetzt werden.

Direkt bevor der kritische Abschnitt wieder verlassen wird, wird lock auf Null zurück gesetzt.

Alle beteiligten Prozesse oder Threads müssen beim Betreten eines kritischen Bereichs den Wert von lock prüfen, und gegebenenfalls warten.

Code

Beim Betreten des kritischen Abschnitts:

while (lock==1);
lock = 1;

Code

Direkt vor dem Verlassen des kritischen Abschnitts:

lock = 0;

Aufgabe 1

Aufgabe

Aufg. : Die Bedeutung des Semikolons!

Die Codezeile

while (lock==1);

ist sehr wichtig. Hier wird der Wert von lock geprüft und gegebenenfalls gewartet. Die Sache mit dem Warten kannst du aber nur verstehen, wenn du die Bedeutung des Semikolons ganz am Ende der Codezeile kennst.

Erläutere: Welche Bedeutung hat das Semikolon in Verbindung mit dem while?

(PS.: Die while-Schleife ist auch der Grund für den großen Nachteil des aktiven Wartens, siehe letzte Aufgabe ganz unten auf dieser Seite!)

Nachdem nun bekannt ist, welcher Code zur Implementierung des aktiven Wartens notwendig ist, kann dieser an den entsprechenden Stellen des Beispielprogramms eingepflegt werden.

Aufgabe 2

Aufgabe

Aufg. : Aktives Warten implementieren

Tu es!
Füge den für das aktive Warten nötigen Code dem Beispielprogramm hinzu.

Aufgabe 3

Aufgabe

Aufg. : Der Nachteil des aktiven Wartens

Welchen großen Nachteil besitzen alle Verfahren, die nach dem Prinzip des aktiven Wartens verfahren?

_{Diese Seite steht unter der Creative Commons Namensnennung 3.0 Unported Lizenz http://i.creativecommons.org/l/by/3.0/80x15.png}

@@ Zeile 49: / Zeile 49: @@
 </p>
 <p>
-Alle beteiligten Prozesse oder Threads müssen beim Betreten ihres kritischen Bereichs den Wert von <span style="font-family:Courier">lock</span> prüfen, und gegebenenfalls warten.
+Alle beteiligten Prozesse oder Threads müssen beim Betreten eines kritischen Bereichs den Wert von <span style="font-family:Courier">lock</span> prüfen, und gegebenenfalls warten.
 </p>
@@ Zeile 95: / Zeile 95: @@
 </loop_task>
 </loop_area>
+</p>
+<br />
+<p>
+Nachdem nun bekannt ist, welcher Code zur Implementierung des aktiven Wartens notwendig ist, kann dieser an den entsprechenden Stellen des [[Kritischer_Abschnitt#Beispiel_zu_kritischen_Abschnitten|Beispielprogramms]] eingepflegt werden.
 </p>
 <br />
 ==== Aufgabe 2 ====
+<p>
+<loop_area type="task">
+<loop_task title="Aktives Warten implementieren">
+<p>
+Tu es!<br />
+Füge den für das aktive Warten nötigen Code dem [[Kritischer_Abschnitt#Beispiel_zu_kritischen_Abschnitten|Beispielprogramm]] hinzu.
+</p>
+<spoiler text="Lösung">
+<p>
+<loop_listing title="Beispiel: Kritische und unkritische Abschnitte" description="Ein Java-Programm mit zwei Threads. Bei Thread_A wechseln sich ein unkritischer, ein kritischer und noch ein unkritischer Abschnitt ab.">
+<source lang="java" line="true">
+public class Beispiel_Kritischer_Abschnitt {
+static int counter = 0;
+static int lock = 0;
+public static class Thread_A extends Thread {
+	public void run() {
+		do_something();          // unkritisch
+		count_from_10();         // kritisch !!!
+		do_something_else();     // unkritisch
+	}
+	private void do_something() {
+		// unkritischer Abschnitt
+		System.out.println("Thread_A: unkritisch");
+	}
+	private void count_from_10() {
+		// Vorsicht: kritischer Abschnitt!
+		while (lock == 1);
+		lock = 1;
+		counter = 10;
+		counter++;
+		counter++;
+		System.out.println("A-Counter: " + counter);
+		lock = 0;
+	}
+	private void do_something_else() {
+		// unkritischer Abschnitt
+		System.out.println("Thread_A: wieder unkritisch");
+	}
+}
+public static class Thread_B extends Thread {
+	public void run() {
+		System.out.println("Thread_B ist gestartet.");
+		while (lock == 1);
+		lock = 1;
+		counter = 20;
+		counter++;
+		counter++;
+		counter++;
+		counter++;
+		counter++;
+		counter++;
+		System.out.println("B-Counter: " + counter);
+		lock = 0;
+	}
+}
+public static void main(String[] args) {
+	Thread a = new Thread_A();
+	Thread b = new Thread_B();
+	a.start();
+	b.start();
+}
+}
+</source>
+</loop_listing>
+</p>
+</spoiler>
+</loop_task>
+</loop_area>
+</p>
+<br />
+==== Aufgabe 3 ====
 <p>
 <loop_area type="task">