3.2.11.2.1 Aktives Warten mit while

[unmarkierte Version][gesichtete Version]
Keine Bearbeitungszusammenfassung
 
Zeile 1: Zeile 1:
=Aktives Warten mit while=
=Aktives Warten mit while=
<p>
Der Code des bereits bekannten [[Kritischer_Abschnitt#Beispiel_zu_kritischen_Abschnitten|Beispiels zu kritischen Abschnitten]] wird um eine (globale) Sperrvariable erweitert, beide Threads haben damit Zugriff auf diese Variable:
</p>
<p>
<loop_area type="sourcecode">
<p>
<span style="font-family:Courier">
static int lock = 0;
</span>
</p>
</loop_area>
</p>
<p>
Besitzt <span style="font-family:Courier">lock</span> 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 <span style="font-family:Courier">lock</span> auf Eins gesetzt werden.
</p>
<p>
Direkt bevor der kritische Abschnitt wieder verlassen wird, wird <span style="font-family:Courier">lock</span> auf Null zurück gesetzt.
</p>
<p>
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>
<p>
<loop_area type="sourcecode">Beim Betreten des kritischen Abschnitts:
<p>
<span style="font-family:Courier">
while (lock == 1);<br />
lock = 1;
</span>
</p>
</loop_area>
</p>
<p>
<loop_area type="sourcecode">Direkt vor dem Verlassen des kritischen Abschnitts:
<p>
<span style="font-family:Courier">
lock = 0;
</span>
</p>
</loop_area>
</p>
<br />
== Aufgabe 1 ==
<p>
<loop_area type="task">
<loop_task title="Die Bedeutung des Semikolons!">
<p>
Die Codezeile
</p>
<p>
<span style="font-family:Courier">while (lock == 1);</span>
</p>
<p>
ist sehr wichtig. Hier wird der Wert von <span style="font-family:Courier">lock</span> 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.
</p>
<p>
Erläutere:<br />
Welche Bedeutung hat das Semikolon in Verbindung mit dem <span style="font-family:Courier">while</span>?
</p>
<p>
Und was würde passieren, wenn das Semikolon versehentlich fehlt:
</p>
<p>
<span style="font-family:Courier">
while (lock == 1) &nbsp; &nbsp; &nbsp; &nbsp;// Hier fehlt das Semikolon, Programmierfehler!<br />
lock = 1;
</span>
</p>
<p>
<small>(PS.: Die <span style="font-family:Courier">while</span>-Schleife ist auch der Grund für den großen Nachteil des aktiven Wartens, siehe letzte Aufgabe ganz unten auf dieser Seite!)</small>
</p>
</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! 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: Aktives Warten" description="Ein Java-Programm mit zwei Threads. Die Sperrvariable soll ein gleichzeitiges Betreten der kritischen Abschnitte durch beide Threads verhindern.">
<source lang="java" line="true">
public class Beispiel_Aktives_Warten {
static int counter = 0;      // gemeinsam genutztes Betriebsmittel
static int lock = 0;          // Sperrvariable
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);      // Semikolon beachten!
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);      // Semikolon beachten!
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 />
<p>
<loop_area type="notice">
<p>
In dieser Lösung wird wieder gezeigt, wie zwei Threads durch die Sperrvariable beeinflusst werden. Es hat den Anschein, als ob ein Anwendungsprogrammierer sich darum kümmern müsste. <small>(Das muss er nur bei den von ihm selbst geschaffenen "Betriebsmitteln". Es sei erneut auf das für diese Zwecke in Java integrierte Schlüsselwort [http://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html synchronized] verwiesen.)</small>
</p>
<p>
Du musst gedanklich hier wieder den Sprung zu Prozessen schaffen, und zu den vielen Betriebsmitteln eines Computersystems, und zum Betriebssystem, und zu Systemaufrufen, über die letztlich das aktive Warten durch das Betriebssystem realisiert werden kann.
</p>
<p>
Dann verstehst du, dass sich der '''Programmierer des Betriebssystems''' darum kümmern muss!
</p>
</loop_area>
</p>
<br />
== Aufgabe 3 ==
<p>
<loop_area type="task">
<loop_task title="Warte aktiv!">
<p>
Spiele in deiner Lerngruppe das Verhalten der beiden Threads aus der [[Aktives_Warten#Aufgabe_2|Lösung zu Aufgabe 2]] durch. Bedenke:
* Es gibt nur eine CPU mit einem Kern. Es kann also nur ein Prozess zur Zeit ausgeführt werden, es kommt zu Quasi-Parallelität.
* Interessant ist die Situation, bei der sich bereits ein Prozess in seinem kritischen Abschnitt befindet, und die Sperre gesetzt hat.
* Der Kontextwechsel erfolgt, und der andere Prozess muss dann an der <span style="font-family:Courier">while</span>-Schleife warten. Tut er das?
</p>
</loop_task>
</loop_area>
</p>
<br />
== Aufgabe 4 ==
<p>
<loop_area type="task">
<loop_task title="Der Nachteil des aktiven Wartens">
<p>
Welchen großen Nachteil besitzen alle Verfahren, die nach dem Prinzip des aktiven Wartens verfahren?
</p>
<spoiler text="Tipp">
<p>
Gemeint ist hier ein ''zeitlicher Nachteil''. Denk mal daran, wie sinnvoll die CPU beschäftigt wird. Wie wirkt sich das deiner Meinung nach auf die Performance des Gesamtsystems aus?
</p>
</spoiler>
</loop_task>
</loop_area>
</p>
<div class="autoit_do_not_print">
<br />
<hr />
<sub>Diese Seite steht unter der [http://creativecommons.org/licenses/by/3.0/deed.de Creative Commons Namensnennung 3.0 Unported Lizenz] [http://creativecommons.org/licenses/by/3.0/deed.de http://i.creativecommons.org/l/by/3.0/80x15.png]
</sub>
</div>

Version vom 6. Februar 2015, 11:34 Uhr

Aktives Warten mit while

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

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?

Und was würde passieren, wenn das Semikolon versehentlich fehlt:

while (lock == 1)        // Hier fehlt das Semikolon, Programmierfehler!
lock = 1;

(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

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


Hinweis

In dieser Lösung wird wieder gezeigt, wie zwei Threads durch die Sperrvariable beeinflusst werden. Es hat den Anschein, als ob ein Anwendungsprogrammierer sich darum kümmern müsste. (Das muss er nur bei den von ihm selbst geschaffenen "Betriebsmitteln". Es sei erneut auf das für diese Zwecke in Java integrierte Schlüsselwort synchronized verwiesen.)

Du musst gedanklich hier wieder den Sprung zu Prozessen schaffen, und zu den vielen Betriebsmitteln eines Computersystems, und zum Betriebssystem, und zu Systemaufrufen, über die letztlich das aktive Warten durch das Betriebssystem realisiert werden kann.

Dann verstehst du, dass sich der Programmierer des Betriebssystems darum kümmern muss!


Aufgabe 3

Aufgabe

Spiele in deiner Lerngruppe das Verhalten der beiden Threads aus der Lösung zu Aufgabe 2 durch. Bedenke:

  • Es gibt nur eine CPU mit einem Kern. Es kann also nur ein Prozess zur Zeit ausgeführt werden, es kommt zu Quasi-Parallelität.
  • Interessant ist die Situation, bei der sich bereits ein Prozess in seinem kritischen Abschnitt befindet, und die Sperre gesetzt hat.
  • Der Kontextwechsel erfolgt, und der andere Prozess muss dann an der while-Schleife warten. Tut er das?


Aufgabe 4

Aufgabe

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