Qu'est-ce qu'une condition de course?

L’état de course est un problème qui survient dans une application multithread ou multiprocessus, lorsque la correction du résultat dépend de l’ordre d’exécution des threads/processus.

Il survient généralement lorsque plusieurs threads accèdent simultanément à des ressources partagées (variables, fichiers, bases de données) sans synchronisation appropriée.

Cela conduit à un comportement imprévisible, des erreurs et des données incorrectes.

Exemple : Deux threads tentent d’augmenter une variable partagée en même temps.

var sharedCounter = 0

func incrementCounter() {
    let currentValue = sharedCounter // Le thread 1 lit 0
    // Un certain retard
    let newValue = currentValue + 1 // Le thread 1 calcule 1
    sharedCounter = newValue // Le thread 1 écrit 1
}

// Si le thread 2 lit currentValue avant que le thread 1 n’écrive newValue :
func anotherIncrementCounter() {
    let currentValue = sharedCounter // Le thread 2 lit 0
    let newValue = currentValue + 1 // Le thread 2 calcule 1
    sharedCounter = newValue // Le thread 2 écrit 1
}

Dans cet exemple, si les deux threads s’exécutent simultanément sans synchronisation, au final sharedCounter peut devenir 1 au lieu de 2 attendu.

Pour éviter les conditions de course, on utilise des mécanismes de synchronisation :

• Mutex (Mutual Exclusion): Bloque l’accès à une ressource, permettant à un seul thread d’être dans la section critique.
• Sémaphores (Semaphore): Limitent le nombre de threads pouvant accéder simultanément à une ressource.
• Queues (Dispatch Queues en GCD): L’exécution des tâches se fait de manière séquentielle (pour les queues sériales) ou avec un certain niveau de parallélisme (pour les queues concurrentes) avec possibilité de synchroniser l’accès.
• Verrous (Locks): Divers types de verrous (par exemple, NSLock, NSRecursiveLock).
• Opérations atomiques (Atomic Operations): Garantissent que l’opération (lecture, écriture, incrément) est effectuée de manière atomique, c’est-à-dire qu’elle ne peut pas être interrompue par un autre thread.

Dans le développement iOS, on utilise souvent Grand Central Dispatch (GCD) et Operation Queues pour gérer les threads et prévenir les conditions de course. Les Dispatch Queues sériales assurent la synchronisation automatique des tâches exécutées dans cette queue.