This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
<meta content="metadata description" lang="en" name="description" xml:lang="en" />
<meta content="description des métadonnées" lang="fr" name="description" xml:lang="fr" />
<meta content="Sphinx, MyST" name="keywords" />
<meta content="en_US" property="og:locale" />
<title>08 - Synchronisationsprobleme — SNP Labs documentation</title>
<link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
<link rel="stylesheet" type="text/css" href="../_static/alabaster.css" />
<script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
<script src="../_static/jquery.js"></script>
<script src="../_static/underscore.js"></script>
<script src="../_static/doctools.js"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
<link rel="next" title="09 - File Operations" href="../P09_File_Operations/README.html" />
<link rel="prev" title="07 - Prozesse und Threads" href="../P07_Prozesse_und_Threads/README.html" />
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
</head><body>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<section class="tex2jax_ignore mathjax_ignore" id="synchronisationsprobleme">
<h1>08 - Synchronisationsprobleme<a class="headerlink" href="#synchronisationsprobleme" title="Permalink to this headline">¶</a></h1>
<hr class="docutils" />
<section id="ubersicht">
<h2>1. Übersicht<a class="headerlink" href="#ubersicht" title="Permalink to this headline">¶</a></h2>
<p><img alt="" src="../_images/synchronisationsprobleme.png" /></p>
<p><a class="reference external" href="https://commons.wikimedia.org/wiki/File:Velgast-suedbahn.jpg">Quelle: https://commons.wikimedia.org/wiki/File:Velgast-suedbahn.jpg</a></p>
<p>In diesem Praktikum lernen sie zuerst am Beispiel eines Kaffee-Automaten verschiedene grundlegende Synchronisationsprobleme kennen und mit Hilfe von Locks (Mutexes) und Semaphoren lösen:</p>
<ul class="simple">
<li><p>gegenseitiger Ausschluss mit einem Lock</p></li>
<li><p>Erzwingen einer einfachen Reihenfolge</p></li>
<li><p>Erzwingen einer erweiterten Reihenfolge</p></li>
</ul>
<p>Im zweiten Teil werden sie auf Basis dieser Grundlagen ein komplexeres Synchronisationsproblem bearbeiten, diesmal am Beispiel von Bank Transaktionen.</p>
<hr class="docutils" />
<section id="nachweis">
<h3>1.1 Nachweis<a class="headerlink" href="#nachweis" title="Permalink to this headline">¶</a></h3>
<p>Dieses Praktikum ist eine leicht abgewandelte Variante des Sync Praktikum des Moduls BSY, angepasst an die Verhältnisse des SNP Moduls. Die Beispiele und Beschreibungen wurden, wo möglich, eins-zu-ein übernommen.</p>
<p>Als Autor des BSY Praktikums ist genannt: M. Thaler.</p>
</section>
</section>
<hr class="docutils" />
<section id="lernziele">
<h2>2. Lernziele<a class="headerlink" href="#lernziele" title="Permalink to this headline">¶</a></h2>
<p>In diesem Praktikum werden sie Synchronisationsprobleme lösen</p>
<ul class="simple">
<li><p>Sie wissen wie man systematisch Synchronisationsprobleme analysiert</p></li>
<li><p>Sie wissen wann ein potentieller Deadlock entstehen kann</p></li>
<li><p>Sie können Mutex mit Threads anwenden</p></li>
<li><p>Sie können Semaphoren mit Prozessen anwenden</p></li>
</ul>
</section>
<hr class="docutils" />
<section id="einfuhrung">
<h2>3. Einführung<a class="headerlink" href="#einfuhrung" title="Permalink to this headline">¶</a></h2>
<p>Das Lösen von Synchronisationsproblemen ist oft nicht einfach, weil Prozesse bzw. Threads gleichzeitig ablaufen, ihre Aktivitäten jedoch nach Vorgaben koordiniert werden müssen: man verliert schnell den Überblick. Systematisches Vorgehen mit Aufzeichnen der Abläufe und Synchronisationsbedingungen bewährt ich sich in diesem Fall.</p>
<hr class="docutils" />
<section id="wie-lost-man-synchronisationsprobleme">
<h3>3.1 Wie löst man Synchronisationsprobleme?<a class="headerlink" href="#wie-lost-man-synchronisationsprobleme" title="Permalink to this headline">¶</a></h3>
<p>Gehen sie beim Lösen von Synchronisationsproblemen in folgenden Schritten vor:</p>
<ul class="simple">
<li><p><strong>Schritt 1: Prozesse (Threads) der Problemstellung identifizieren.</strong><br />
Prozesse sind die Aktivitäten, die gleichzeitig ausgeführt werden. In diesem Sinne sind sie eigenständige Ausführungs-Einheiten, deren zeitliches Verhalten synchronisiert werden muss.</p></li>
<li><p><strong>Schritt 2: Ausführungsschritte der einzelnen Prozesse (Threads) ermitteln.</strong><br />
Erstellen sie eine Liste mit einer Spalte für jeden Prozess. Notieren sie für jeden Prozess stichwortartig die wesentlichen Aktionen in der gewünschten zeitlichen Reihenfolge. Tragen sie noch keine Synchronisationsoperationen ein, sondern Texte wie warten auf Geld, etc. Übertragen sie anschliessend die Liste in einen Ablaufgraphen (Siehe Beispiel in Abbildung 1).</p></li>
<li><p><strong>Schritt 3: Synchronisationsbedingungen ermitteln.</strong><br />
Eine Synchronisationsbedingung ist eine zeitliche Beziehung (Abhängigkeit) zwischen Aktionen verschiedener Prozesse, die für das korrekte Arbeiten erforderlich ist. Zeichnen sie diese Beziehungen mit Pfeilen in den Ablaufgraphen aus Schritt 2 ein (Siehe Abbildung 1).</p></li>
<li><p><strong>Schritt 4: Benötigte Semaphore definieren.</strong><br />
Für jede Synchronisationsbedingung wird ein eigener Semaphor benötigt. Notieren sie für jeden Semaphor einen Namen und den Wert, mit dem er initialisiert werden muss.</p></li>
<li><p><strong>Schritt 5: Prozesse mit Semaphore Operationen ergänzen.</strong><br />
Erweitern sie nun alle Prozesse aus Schritt 2 mit den notwendigen Semaphore Operati-onen (Siehe Pseudocode in Abbildung 1).</p></li>
<li><p><strong>Schritt 6: Implementation.</strong><br />
Implementieren und testen sie das vollständige Programm.</p></li>
</ul>
<p><img alt="" src="../_images/coffee_customer.png" /></p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">coin</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">sem_open</span><span class="p">(...,</span><span class="mi">0</span><span class="p">);</span><span class="w"></span>
<span class="n">coffee</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">sem_open</span><span class="p">(...,</span><span class="mi">0</span><span class="p">);</span><span class="w"></span>
</pre></div>
</div>
<p>Ablaufgraph und Pseudocode für 2 Prozesse und zwei Semaphore<br />
<img alt="" src="../_images/sequence_graph.png" /></p>
</section>
</section>
<section id="der-kaffee-automat">
<h2>4. Der Kaffee-Automat<a class="headerlink" href="#der-kaffee-automat" title="Permalink to this headline">¶</a></h2>
<p>Als Beispiel verwenden wir einen Automaten, der Kaffee verkauft. Der Kunde muss zum Kauf eines Kaffees zuerst eine bzw. mehrere Münzen einwerfen und anschliessend den gewünsch-ten Kaffee wählen. Der Automat gibt dann das entsprechende Getränk aus.</p>
<p>Im ersten Beispiel werden der Automat und die Kunden mit Threads modelliert und tauschen Daten über gemeinsame Speichervariablen aus. Im zweiten und dritten Beispiel werden der Automat und die Kunden mit Prozessen modelliert, dabei wird der Ablauf mit Hilfe von Sema-phoren gesteuert bzw. erzwungen.</p>
<p><strong>Hinweis:</strong> die Programme zu den folgenden Aufgaben können alle mit <strong>startApp.e</strong> gestartet werden. Dieses Programm startet und stoppt Threads und Prozesse, alloziert und dealloziert die Ressourcen (Mutexes, Semaphore).</p>
<hr class="docutils" />
<section id="aufgabe-mutual-exclusion">
<h3>4.1 Aufgabe: Mutual Exclusion<a class="headerlink" href="#aufgabe-mutual-exclusion" title="Permalink to this headline">¶</a></h3>
<p>Greifen mehrere Threads (oder Prozesse) auf gemeinsame Daten zu, können sogenannte Race Conditions entstehen. Das Resultat ist in diesem Fall abhängig von der Reihenfolge, in der die Threads (Prozesse) ausgeführt werden.</p>
<p>Im vorliegenden Beispiel wirft der Kunde eine 1 Euro Münze ein und drückt anschliessend auf eine von zwei Kaffeewahltasten. Dabei wird die Anzahl Münzen (<em>coinCount</em>) und die gewählte Kaffeesorte (<em>selCount1</em>, <em>selCount2</em>) inkrementiert. Diese Variablen sind in der Datenstruktur <em>cData</em> abgelegt, auf die gemeinsam Kaffee-Automat und Kunden zugreifen können. Der Auto-mat überprüft, ob die Anzahl Münzen und die Anzahl der Kaffeewahlen gleich gross sind, falls nicht, wird eine Fehlermeldung ausgegeben und alle Zähler auf <em>Null</em> gesetzt.</p>
<section id="aufgaben">
<h4>Aufgaben<a class="headerlink" href="#aufgaben" title="Permalink to this headline">¶</a></h4>
<ol class="arabic simple">
<li><p>Übersetzen sie die Programme im Verzeichnis <em>mutex</em> mit <em>make</em> und starten sie den Kaffee-Automaten mit <strong>startApp.e</strong> mehrmals hintereinander.
Analysieren sie die Datenwerte in den Fehlermeldungen, beschreiben sie was die Gründe dafür sind bzw. sein können.</p></li>
<li><p>Schützen sie nun den Zugriff auf die gemeinsamen Daten mit einem Mutex so, dass alle Threads eine konsistente Sicht der Daten haben.
Wir haben für sie einen Mutex vorbereitet: die Datenstruktur <em>cData</em> enthält die Mutex-Variable <em>mutex</em>, die in <strong>startApp.c</strong> initialisiert wird. Die Funktionen für das Schliessen und das Öffnen des Mutex (Locks) aus der <em>pthread</em> Bibliothek sind:</p></li>
</ol>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">pthread</span><span class="w"> </span><span class="n">mutex</span><span class="w"> </span><span class="n">lock</span><span class="p">(</span><span class="o">&</span><span class="p">(</span><span class="n">cD</span><span class="o">-></span><span class="n">lock</span><span class="p">));</span><span class="w"></span>
</pre></div>
</div>
<ul class="simple">
<li><p>und</p></li>
</ul>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">pthread</span><span class="w"> </span><span class="n">mutex</span><span class="w"> </span><span class="n">unlock</span><span class="p">(</span><span class="o">&</span><span class="p">(</span><span class="n">cD</span><span class="o">-></span><span class="n">lock</span><span class="p">));</span><span class="w"></span>
</pre></div>
</div>
<p>Überprüfen sie, ob der Kaffee-Automat nun keine Fehlermeldungen mehr ausgibt. Erhö-hen sie dazu auch die Anzahl Kunden <em>CUSTOMERS</em> in <strong>commonDefs.h</strong>, z.B. auf 10.</p>
<ol class="arabic simple" start="3">
<li><p>Im Thread des Kaffee-Automaten wird an verschiedenen Orten mehrmals auf die gemeinsamen Daten in <em>cD</em> zugegriffen. Wenn sie die gemeinsamen Daten in lokale Variablen kopieren und dann nur noch auf diese lokalen Variablen zugreifen würden, könn-ten sie dann auf die Synchronisation mit dem Mutex verzichten?</p></li>
<li><p>Wie oft kann ein einzelner Kunde einen Kaffee beziehen, bis der nächste Kunde an die Reihe kommt? Hier reicht eine qualitative Aussage.</p></li>
</ol>
</section>
</section>
<section id="aufgabe-einfache-reihenfolge">
<h3>4.2 Aufgabe: Einfache Reihenfolge<a class="headerlink" href="#aufgabe-einfache-reihenfolge" title="Permalink to this headline">¶</a></h3>
<p>Wie sie im ersten Beispiel festgestellt haben, verhindert ein Mutex zwar, dass Race Conditions auftreten, die Verarbeitungsreihenfolge der Threads lässt sich jedoch nicht beeinflussen und ist zufällig.
Im Folgenden soll eine erzwungene Verarbeitungsreihenfolge implementiert werden:</p>
<ul class="simple">
<li><p>Ein Kunde benutzt den Automat für einen Kaffeekauf exklusiv, d.h. alle Schritte des Kunden werden innerhalb eines Mutexes ausgeführt. Ist ein Kunde an der Reihe, wartet er bis der Automat bereit ist, wirft eine Münze ein, wartet auf den Kaffee und gibt anschlies-send den Automaten für den nächsten Kunden frei.</p></li>
<li><p>Der Automat meldet zuerst in einer Endlos-Schleife, dass er für die Geld-Eingabe bereit ist, wartet dann auf die Eingabe einer Münze, gibt den Kaffee aus und meldet anschliessend wieder, wenn er bereit ist, etc.</p></li>
</ul>
<p>Für die Lösung dieses Problems benötigen wir Semaphore, die, im Gegensatz zu Mutexes, auch in verschiedenen Prozessen gesetzt bzw. zurückgesetzt werden dürfen. Den Kaffee-Automat und die Kunden implementieren wir mit Prozessen. sie finden die entsprechenden Prozesse im Verzeichnis <strong>basicSequence</strong>.</p>
<section id="id1">
<h4>Aufgaben<a class="headerlink" href="#id1" title="Permalink to this headline">¶</a></h4>
<ol class="arabic simple">
<li><p>Beschreiben sie den Kaffee-Automaten mit Hilfe der 6 Schritte aus Abschnitt 3 auf Papier, dokumentieren sie dabei alle Schritte schriftlich.</p></li>
<li><p>Implementieren sie nun den Kaffee-Automaten. Ergänzen sie dazu den <em>coffeeTeller</em> und den <em>customer</em> Prozess so mit vier Semaphoren, dass die vorgegebenen Ablaufbedingungen eingehalten werden. Mit welchen Werten müssen die Semaphore initialisiert werden?
Wir haben für sie vier Semaphore vorbereitet: Achtung, sie sind aber noch auskommentiert (siehe commonDefs.h und startApp.c. Die benötigten Semaphor-Funktionen aus der POSIX Bibliothek sind:</p></li>
</ol>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">sem_wait</span><span class="p">(</span><span class="o">&</span><span class="n">semaphor</span><span class="p">);</span><span class="w"></span>
</pre></div>
</div>
<p>und</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="n">sem_post</span><span class="p">(</span><span class="o">&</span><span class="n">semaphor</span><span class="p">);</span><span class="w"></span>
</pre></div>
</div>
<p>Analysieren sie die Ausgabe der Prozesse (mehrmals starten). Was fällt auf?</p>
<ol class="arabic simple" start="3">
<li><p>Gibt Ihr Programm den Output in der korrekten Reihenfolge aus? Falls nicht, wie könnte das gelöst werden?</p></li>
</ol>
</section>
</section>
<section id="aufgabe-erweiterte-reihenfolge">
<h3>4.3 Aufgabe: Erweiterte Reihenfolge<a class="headerlink" href="#aufgabe-erweiterte-reihenfolge" title="Permalink to this headline">¶</a></h3>
<p>Die Preise steigen dauernd … auch der Kaffee wird immer teurer, er kostet nun 3 Euro. Da der Automat nur 1 Euro Stücke annehmen kann, muss der Kunde 3 Münzen einwerfen. Erweitern sie die Prozesse aus Aufgabe 4.2 so, dass eine vordefinierte Anzahl Münzen eingegeben werden muss (die Anzahl Münzen ist in <em>commonDefs.h</em> als <em>NUM_COINS</em> definiert). Verwenden sie keine zusätzlichen Semaphore, sondern nutzen sie, dass wir Counting Semaphore verwenden. Die vordefinierten Prozesse finden sie im Verzeichnis <em>advancedSequence</em>.</p>
<section id="aufgabe">
<h4>Aufgabe<a class="headerlink" href="#aufgabe" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p>Passen sie den coffeeTeller und den customer Prozess so an, dass der Kunde mehrere Münzen einwerfen muss, bis der Automat einen Kaffee ausgeben kann.</p></li>
</ul>
<p><strong>Hinweis:</strong> POSIX Semaphore sind Counting Semaphore, können aber nicht auf vordefinierte Werte gesetzt werden (ausser bei der Initialisierung). Abhilfe schafft hier das mehrmalige Aufrufen von <em>sem_post()</em>, z.B. in einer for-Schleife.</p>
</section>
</section>
<section id="zusammenfassung">
<h3>4.4 Zusammenfassung<a class="headerlink" href="#zusammenfassung" title="Permalink to this headline">¶</a></h3>
<p>Wir haben drei grundlegenden Typen von Synchronisationsproblemen kennen gelernt:</p>
<ul class="simple">
<li><p><strong>Mutex</strong> nur ein Prozess bzw. Thread kann gleichzeitig auf gemeinsame Daten zugreifen.</p>
<ul>
<li><p>Beispiel: entweder liest der Kaffee-Automat die Daten oder ein Kunde verändert sie.</p></li>
</ul>
</li>
<li><p><strong>Einfache Reihenfolge</strong> ein Prozess wartet auf die Freigabe durch einen anderen Prozess.</p>
<ul>
<li><p>Beispiel: der Kaffee-Automat wartet auf die Eingabe einer Münze.</p></li>
</ul>
</li>
<li><p><strong>Erweiterte Reihenfolge</strong> ein Prozess wartet auf mehrere Freigaben durch einen anderen Pro-zess.</p>
<ul>
<li><p>Beispiel: der Kaffee-Automat wartet auf die Eingabe von drei Münzen.</p></li>
</ul>
</li>
</ul>
</section>
</section>
<hr class="docutils" />
<section id="international-banking">
<h2>5. International Banking<a class="headerlink" href="#international-banking" title="Permalink to this headline">¶</a></h2>
<p>Die International Bank of Transfer (IBT) besitzt in 128 Ländern Filialen und stellt für 2048 spezielle Handels-Kunden in jeder Filiale ein Konto zur Verfügung. Gelder dieser Kunden werden dauernd zwischen den Filialen hin und her transferiert, dazu beschäftigt die Bank sogenannte Pusher. Pusher heben Geldbeträge von Konten in einer Filiale ab und buchen sie auf den entsprechenden Konten in irgendeiner (auch in der eigenen) Filiale wieder ein. Die Beträge liegen zwischen 1000 und 100’ –
df107291a5