Threads und Deadlocks

Der Einsatz von Sperren zur Thread-Synchronisation birgt immer ein Deadlock-Risiko. Blockierungen treten dann auf, wenn zwei Sperren in unterschiedlicher Reihenfolge benutzt werden. Das folgende Beispiel zeigt exemplarisch eine fehlerhafte Implementierung, die im Multithreading-Einsatz zu Deadlocks führen wird.

public void Foo1()
{
  lock(m_SyncRoot1)
  {
    ...
    lock(m_SyncRoot2)
    {
    }
    ....
  }
}

public void Foo2()
{
  lock(m_SyncRoot2)
  {
    ...
    lock(m_SyncRoot1)
    {
    }
    ....
  }
}

Solche Fehler sind schwer zu finden, da sie meist nur sporadisch auftreten. Noch schwerer wird es, wenn die Sperren durch aufgerufene Funktionen angefordert werden. Deshalb sollten immer Maßnahmen getroffen werden, um Deadlocks von vornherein zu unterbinden.

Lokaler Einsatz von Sperren

Durch den lokalen Einsatz von Sperren können Deadlocks vermieden werden, wenn weitere Bedingungen erfüllt sind:

1. Das Synchronisationsobjekt (auch Mutex oder CriticalSection) wird nur lokal benutzt, also z.B. innerhalb einer Klasse.
2. Innerhalb von synchronisierten Bereichen werden keine Ereignisse (Delegates bzw. Callbacks) aufgerufen.
3. Innerhalb von synchronisierten Bereichen werden keine virtuellen Funktionen aufgerufen.

Ähnliche Artikel

• Thread-sichere Funktionen
• Sicheres Beenden von Timer-Instanzen
• Manuelle Thread-Synchronisation
• Automatische Thread-Synchronisation