Que fait la synchronisation dans le contexte du multithreading?

La synchronisation dans le contexte de la multitâche empêche les conditions de course et garantit un accès cohérent aux ressources partagées (variables, fichiers, connexions réseau) depuis différents threads.

Les mécanismes principaux de synchronisation :

• Mutex (mutual exclusion) : Un seul thread peut posséder le mutex et accéder à la ressource protégée.
• Semaphore (sémaphore) : Limite le nombre de threads pouvant accéder simultanément à une ressource. Fonctionne avec un compteur.
• Lock (verrou) : Concept généralisé, souvent utilisé pour désigner des mutex ou d'autres mécanismes qui bloquent complètement l'accès.
• Dispatch Queue (file d'attente de dispatch) : Dans Grand Central Dispatch (GCD), les files peuvent être séquentielles (série) ou concurrentes, assurant la synchronisation en contrôlant l'ordre et le nombre de tâches exécutées simultanément. Les files séquentielles garantissent l'exécution des tâches une par une, ce qui fournit intrinsèquement une synchronisation pour les données accessibles uniquement depuis les tâches de cette file.

Principe de fonctionnement : Un thread souhaitant accéder à une ressource partagée tente d'abord d'acquérir un verrou (lock). Si la ressource est libre, le thread obtient le verrou et travaille avec la ressource. À la fin, il libère le verrou (release lock). Si la ressource est occupée, d'autres threads se bloquent (attendent) jusqu'à ce que la ressource soit libérée.

Exemple d'utilisation d'un mutex pour protéger une section critique :

// Exemple en Objective-C utilisant @synchronized
- (void)updateSharedResource {
    @synchronized (self) { // Verrouillage sur l'objet self
        // La section critique est ici
        // L'accès à sharedResource est sécurisé
        self.sharedResource++;
    } // Le verrou est automatiquement libéré à la sortie du bloc
}

// Exemple en Swift utilisant NSLock
let lock = NSLock()
var sharedCounter = 0

func incrementCounter() {
    lock.lock() // Tentative d'acquisition du verrou
    // Section critique
    sharedCounter += 1
    lock.unlock() // Libération du verrou
}

La synchronisation permet d'éviter des problèmes tels que :

• Corruption des données.
• Deadlock (blocage mutuel) des threads.
• Livelock (blocages actifs) des threads.

Le choix du mécanisme de synchronisation dépend de la nature de la tâche et du type de ressource.