imported>BrunoBoehmler: /* Einleitung */ Belege-Baustein eingefügt

2026-04-20T20:56:12Z

Einleitung: Belege-Baustein eingefügt

Neue Seite

{{Belege fehlen}}
Ein '''Spinlock''' (Spin-Lock) ist ein Mechanismus zur [[Prozesssynchronisation]]. Es ist eine Sperre ([[Lock]]) zum Schutz einer gemeinsam genutzten Ressource durch konkurrierende Prozesse bzw. Threads ''(siehe [[Kritischer Abschnitt]])'' nach dem Prinzip des wechselseitigen Ausschlusses ([[Mutex]]).

== Implementierung ==
Die Sperre wird umgesetzt mittels [[Aktives Warten|aktiven Wartens]]:
<pre>
// Eintrittsprotokoll
solange (Sperrvariable besitzt Wert 'gesperrt') { // \
tue nichts; // | Achtung! Hier:
} // | Atomares Vergleichen und Setzen
setze Sperrvariable auf 'gesperrt' // /

// Kritischer Abschnitt
modifiziere Ressource

// Austrittsprotokoll
setze Sperrvariable auf 'frei'
</pre>
Zu Anfang besitzt die Sperrvariable den Wert ''frei''. Alle Prozesse durchlaufen für den Eintritt in einen kritischen Abschnitt das gleiche Protokoll: Wenn die Sperrvariable ''frei'' ist, setze sie auf ''gesperrt'', ansonsten prüfe dies erneut (aktives Warten). Das Prüfen und Setzen erfolgt [[Atomare Operation|atomar]] und wird je nach Prozessorarchitektur unterschiedlich implementiert (siehe [[Fetch-and-add]], [[Compare-and-swap]] oder [[Test-and-set]]).

Der Prozess, der die Sperrvariable auf ''gesperrt'' setzt, wird als „Besitzer“ der Sperrvariablen bezeichnet.

== Vorteile ==
Das Verfahren vermeidet [[Kontextwechsel]], die sehr zeitaufwändig sind. Wenn das Warten auf die Freigabe einer Sperre im Mittel kürzer als ein Kontextwechsel ist, dann sind Spinlocks trotz ihrer zusätzlichen [[Laufzeit (Informatik)|Laufzeit]] schneller als alternative [[Mutex]]e. Dies erhöht die ''effektive Parallelität'' gegenüber threadwechselnden Synchronisationsmechanismen teilweise erheblich und ist daher bei stark nebenläufigen Algorithmen eine häufig anzutreffende Vorgehensweise (z. B. im [[Linux (Kernel)|Linux-Kernel]]<ref name="linux_kernel_spinlocks">{{cite web |url=https://www.kernel.org/doc/Documentation/locking/spinlocks.txt |title=Lesson 1: Spin locks |date=12. August 2013 |website=The Linux Kernel Archives |publisher=Page maintained by Rob Landley, rob at landley dot net |accessdate=2013-11-04}}</ref>).

== Nachteile ==
Das aktive Warten benötigt [[Laufzeit (Informatik)|Laufzeit]]. Ein Spinlock kann die Programmausführung stark verlangsamen, wenn mehr Threads als Prozessorkerne vorhanden sind.

In Abhängigkeit vom Schedulingverfahren kann der Einsatz von Spinlocks auch zu [[Deadlock (Informatik)|Deadlocks]] führen. Dies resultiert aus dem Umstand, dass durch einen Spinlock der aktive Thread nicht suspendiert wird, sondern aktiv auf die Sperrvariable wartet (also ''ablaufend'' bleibt) und dadurch andere ''ablaufbereite'' Threads behindert. Folgendes Beispiel verdeutlicht das Problem: In einem Einprozessorsystem mit zwei Threads wird ein Spinlock von einem Thread L mit ''geringer'' Priorität erfolgreich gesperrt. Kurz darauf (und vor der Freigabe des Spinlocks durch Thread L) wird ein Thread H mit ''hoher'' Priorität durch ein Ereignis lauffähig und vom [[Prozess-Scheduler|Scheduler]] aktiviert. Thread H versucht nun ebenfalls, den Spinlock zu sperren, und gerät dadurch in das aktive Warten. Bei einem Schedulingverfahren ohne [[Zeitscheibenverfahren|Time Slicing]] entsteht dadurch ein Deadlock, da Thread L nicht wieder lauffähig wird und den Spinlock nicht mehr freigeben kann. Die Verwendung eines Synchronisationsmechanismus mit Threadwechsel hätte in diesem Beispiel den Deadlock verhindert.

== Literatur ==
* {{Literatur |Autor=Sándor Juhász, Ákos Dudás, Tamás Schrádi |Titel=Cost of mutual exclusion with spin locks on multi-core CPUs |Sammelwerk=Proceedings of the 5th WSEAS congress on Applied Computing conference, and Proceedings of the 1st international conference on Biologically Inspired Computation |Reihe=BICA’12 |Verlag=World Scientific and Engineering Academy and Society (WSEAS) |Ort=Stevens Point WI |Datum=2012 |ISBN=978-1-61804-089-3 |Seiten=15–19 |Kommentar=Conference Paper |Online=https://dl.acm.org/doi/10.5555/2230596.2230600}}
* {{Literatur |Autor=Mordechai Ben-Ari |Titel=Principles of Concurrent and Distributed Programming: Algorithms and Models |Reihe=Prentice-Hall International Series in Computer Science |Auflage=2 |Verlag=Addison-Wesley |Datum=2005 |ISBN=978-0-321-31283-9}}
* {{Literatur |Autor=James H. Anderson, Yong-Jik Kim, Ted Herman |Titel=Shared-memory mutual exclusion: major research trends since 1986 |Sammelwerk=Distrib. Comput. |Band=16 |Nummer=2–3 |Verlag=Springer-Verlag |Ort=London UK |Datum=2003-09 |ISSN=0178-2770 |Seiten=75–110 |DOI=10.1007/s00446-003-0088-6}}
* {{Literatur |Autor=M. Raynal, D. Beeson |Titel=Algorithms for mutual exclusion |Verlag=MIT Press |Ort=Cambridge MA |Datum=1986 |ISBN=0-262-18119-3}}

== Einzelnachweise ==
<references />

[[Kategorie:Parallelverarbeitung]]

Spinlock - Versionsgeschichte

imported>BrunoBoehmler: /* Einleitung */ Belege-Baustein eingefügt