Es gibt zwei wesentliche Konzepte für die Erstellung gleichzeitiger Programme: Synchronisation und gegenseitiger Ausschluss. Wir werden sehen, wie diese beiden Arten von Sperren (Semaphoren sind im Allgemeinen eine Art Sperrmechanismus) uns helfen, Synchronisation und gegenseitigen Ausschluss zu erreichen.
Ein Semaphor ist ein Programmierkonstrukt, das uns hilft, Parallelität zu erreichen, indem sowohl Synchronisation als auch gegenseitiger Ausschluss implementiert werden. Es gibt zwei Arten von Semaphoren: Binär und Zählen.
Ein Semaphor besteht aus zwei Teilen: einem Zähler und einer Liste von Aufgaben, die auf den Zugriff auf eine bestimmte Ressource warten. Ein Semaphor führt zwei Operationen aus: Warten (P) [dies ist wie das Erhalten einer Sperre] und Loslassen (V) [ähnlich wie das Aufheben einer Sperre] - dies sind die einzigen zwei Operationen, die man an einem Semaphor ausführen kann. In einem binären Semaphor bewegt sich der Zähler logischerweise zwischen 0 und 1. Sie können sich vorstellen, dass er einer Sperre mit zwei Werten ähnelt: offen / geschlossen. Ein Zählsemaphor hat mehrere Werte für die Zählung.
Es ist wichtig zu verstehen, dass der Semaphorzähler die Anzahl der Aufgaben verfolgt, die nicht blockiert werden müssen, dh Fortschritte erzielen können. Aufgaben blockieren und fügen sich nur dann zur Liste des Semaphors hinzu, wenn der Zähler Null ist. Daher wird eine Aufgabe zur Liste in der Routine P () hinzugefügt, wenn sie nicht fortgesetzt werden kann, und mit der Routine V () "freigegeben".
Nun ist es ziemlich offensichtlich zu sehen, wie binäre Semaphoren verwendet werden können, um Synchronisation und gegenseitigen Ausschluss zu lösen - sie sind im Wesentlichen Sperren.
Ex. Synchronisation:
thread A{
semaphore &s; //locks/semaphores are passed by reference! think about why this is so.
A(semaphore &s): s(s){} //constructor
foo(){
...
s.P();
;// some block of code B2
...
}
//thread B{
semaphore &s;
B(semaphore &s): s(s){} //constructor
foo(){
...
...
// some block of code B1
s.V();
..
}
main(){
semaphore s(0); // we start the semaphore at 0 (closed)
A a(s);
B b(s);
}
Im obigen Beispiel kann B2 erst ausgeführt werden, nachdem B1 die Ausführung beendet hat. Angenommen, Thread A wird zuerst ausgeführt - gelangt zu sem.P () und wartet, da der Zähler 0 (geschlossen) ist. Faden B kommt, beendet B1 und gibt dann Faden A frei - der dann B2 vervollständigt. So erreichen wir die Synchronisation.
Betrachten wir nun den gegenseitigen Ausschluss mit einem binären Semaphor:
thread mutual_ex{
semaphore &s;
mutual_ex(semaphore &s): s(s){} //constructor
foo(){
...
s.P();
//critical section
s.V();
...
...
s.P();
//critical section
s.V();
...
}
main(){
semaphore s(1);
mutual_ex m1(s);
mutual_ex m2(s);
}
Der gegenseitige Ausschluss ist ebenfalls recht einfach - m1 und m2 können nicht gleichzeitig in den kritischen Bereich eintreten. Daher verwendet jeder Thread dasselbe Semaphor, um die beiden kritischen Abschnitte gegenseitig auszuschließen. Ist es nun möglich, eine größere Parallelität zu erreichen? Kommt auf die kritischen Abschnitte an. (Überlegen Sie, wie man sonst Semaphoren verwenden könnte, um einen gegenseitigen Ausschluss zu erreichen. Hinweis Hinweis: Muss ich unbedingt nur ein Semaphor verwenden?)
Semaphor zählen: Ein Semaphor mit mehr als einem Wert. Schauen wir uns an, was dies bedeutet - eine Sperre mit mehr als einem Wert? Also offen, geschlossen und ... hmm. Was nützt eine mehrstufige Sperre beim gegenseitigen Ausschluss oder bei der Synchronisation?
Nehmen wir das leichtere von beiden:
Synchronisation mit einem Zählsemaphor: Angenommen, Sie haben 3 Aufgaben - Nr. 1 und 2, die Sie nach 3 ausführen möchten. Wie würden Sie Ihre Synchronisation gestalten?
thread t1{
...
s.P();
//block of code B1
thread t2{
...
s.P();
//block of code B2
thread t3{
...
//block of code B3
s.V();
s.V();
}
Wenn Ihr Semaphor also geschlossen beginnt, stellen Sie sicher, dass der Block t1 und t2 zur Liste des Semaphors hinzugefügt wird. Dann kommt alles wichtige t3, beendet sein Geschäft und befreit t1 und t2. In welcher Reihenfolge werden sie befreit? Hängt von der Implementierung der Semaphorliste ab. Könnte FIFO sein, könnte eine bestimmte Priorität haben usw. (Hinweis: Überlegen Sie, wie Sie Ihre Ps und Vs anordnen würden, wenn t1 und t2 in einer bestimmten Reihenfolge ausgeführt werden sollen und wenn Sie sich der Implementierung des Semaphors nicht bewusst sind.)
(Finden Sie heraus: Was passiert, wenn die Anzahl der Vs größer ist als die Anzahl der Ps?)
Gegenseitiger Ausschluss Verwenden von Zählsemaphoren: Ich möchte, dass Sie dafür Ihren eigenen Pseudocode erstellen (damit Sie die Dinge besser verstehen!) - aber das grundlegende Konzept lautet: Ein Zählsemaphor von counter = N ermöglicht es N Aufgaben, frei in den kritischen Abschnitt einzutreten . Dies bedeutet, dass Sie N Aufgaben (oder Threads, wenn Sie möchten) in den kritischen Bereich eingeben, aber die N + 1-Aufgabe blockiert wird (wird in unsere Liste der bevorzugten blockierten Aufgaben aufgenommen) und nur dann durchgelassen wird, wenn jemand V das Semaphor ist zumindest einmal. Anstatt zwischen 0 und 1 zu schwingen, bewegt sich der Semaphorzähler jetzt zwischen 0 und N, sodass N Aufgaben frei ein- und ausgehen können und niemand blockiert wird!
Nun meine Güte, warum brauchst du so ein dummes Ding? Ist es nicht der Sinn des gegenseitigen Ausschlusses, nicht mehr als einen Mann auf eine Ressource zugreifen zu lassen? (Hinweis Hinweis ... Sie haben nicht immer nur ein Laufwerk in Ihrem Computer, oder ...?)
Zu denken : Wird gegenseitiger Ausschluss durch ein Zählsemaphor allein erreicht? Was ist, wenn Sie 10 Instanzen einer Ressource haben und 10 Threads (über das Zählsemaphor) eingehen und versuchen, die erste Instanz zu verwenden?
