Was macht die Synchronisation im Kontext der Multithreading?

Die Synchronisation im Kontext der Multithreading-Programmierung verhindert Race Conditions und stellt einen konsistenten Zugriff auf gemeinsam genutzte Ressourcen (Variablen, Dateien, Netzwerkverbindungen) aus verschiedenen Threads sicher.

Die wichtigsten Synchronisationsmechanismen:

• Mutex (Mutual Exclusion): Nur ein Thread kann den Mutex besitzen und auf die geschützte Ressource zugreifen.
• Semaphore: Begrenzung der Anzahl der Threads, die gleichzeitig auf eine Ressource zugreifen können. Funktioniert mit einem Zähler.
• Lock: Allgemeiner Begriff, der oft verwendet wird, um Mutex oder andere Mechanismen zu bezeichnen, die den Zugriff vollständig blockieren.
• Dispatch Queue (Aufgabenwarteschlange): In Grand Central Dispatch (GCD) können Warteschlangen sequenziell (seriell) oder parallel sein, was die Synchronisation durch Steuerung der Reihenfolge und Anzahl gleichzeitig ausgeführter Aufgaben gewährleistet. Serielle Warteschlangen garantieren die Ausführung der Aufgaben nacheinander, was inhärent Synchronisation für Daten bietet, auf die nur aus den Aufgaben dieser Warteschlange zugegriffen wird.

Funktionsprinzip: Ein Thread, der auf eine gemeinsame Ressource zugreifen möchte, versucht zunächst, eine Sperre (Lock) zu erwerben. Ist die Ressource frei, erhält der Thread die Sperre und arbeitet mit der Ressource. Nach Abschluss gibt er die Sperre frei (release lock). Ist die Ressource belegt, werden andere Threads blockiert (warten), bis die Ressource freigegeben wird.

Beispiel für die Verwendung eines Mutex zum Schutz eines kritischen Abschnitts:

// Beispiel in Objective-C mit @synchronized
- (void)updateSharedResource {
    @synchronized (self) { // Sperre auf dem Objekt self
        // Hier wird der kritische Abschnitt ausgeführt
        // Der Zugriff auf sharedResource ist sicher
        self.sharedResource++;
    } // Sperre wird automatisch beim Verlassen des Blocks freigegeben
}

// Beispiel in Swift mit NSLock
let lock = NSLock()
var sharedCounter = 0

func incrementCounter() {
    lock.lock() // Versuch, die Sperre zu erwerben
    // Kritischer Abschnitt
    sharedCounter += 1
    lock.unlock() // Sperre freigeben
}

Die Synchronisation hilft, Probleme wie:

• Datenbeschädigung.
• Deadlock (gegenseitiges Blockieren) von Threads.
• Livelock (aktive Blockierungen) von Threads.

Die Wahl des geeigneten Synchronisationsmechanismus hängt von der Natur der Aufgabe und der Art der Ressource ab.