Spinlock

aus Wikipedia, der freien Enzyklopädie
Wechseln zu: Navigation, Suche

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[Bearbeiten]

Die Sperre wird umgesetzt mittels aktiven Wartens:

// 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'

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 atomar und wird je nach Prozessorarchitektur anders implementiert (siehe Fetch-and-add, Compare-and-swap oder Test-and-set).

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

Vorteile[Bearbeiten]

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 schneller als alternative Mutexe. 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[1]).

Nachteile[Bearbeiten]

Das aktive Warten benötigt 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 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 Scheduler aktiviert. Thread H versucht nun ebenfalls den Spinlock zu sperren und gerät dadurch in das aktive Warten. Bei einem Schedulingverfahren ohne 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[Bearbeiten]

  •  Juhász, Sándor and Dudás, Ákos and Schrádi, Tamás: Cost of mutual exclusion with spin locks on multi-core CPUs. In: Proceedings of the 5th WSEAS congress on Applied Computing conference, and Proceedings of the 1st international conference on Biologically Inspired Computation (= BICA'12). World Scientific and Engineering Academy and Society (WSEAS), Stevens Point, Wisconsin, USA 2012, ISBN 978-1-61804-089-3, S. 15–19 (http://dl.acm.org/citation.cfm?id=2230596.2230600).
  •  Ben-Ari, Mordechai: Principles of Concurrent and Distributed Programming: Algorithms and Models (= Prentice-Hall International Series in Computer Science). Zweite Auflage. Addison Wesley, 29. November 2005, ISBN 978-0321312839.
  •  Anderson, James H. and Kim, Yong-Jik and Herman, Ted: Shared-memory mutual exclusion: major research trends since 1986. In: Distrib. Comput.. 16, Nr. 2–3, Springer-Verlag, London, UK, UK sep 2003, ISSN 0178-2770, S. 75–110, doi:10.1007/s00446-003-0088-6 (http://dx.doi.org/10.1007/s00446-003-0088-6).
  •  Raynal, M. and Beeson, D.: Algorithms for mutual exclusion. MIT Press, Cambridge, MA, USA 1986, ISBN 0-262-18119-3.

Einzelnachweise[Bearbeiten]

  1. Lesson 1: Spin locks. Page maintained by Rob Landley, rob at landley dot net. 12. August 2013. Abgerufen am 4. November 2013.