Quels sont les moyens d'assurer la sécurité des threads dans les applications iOS?

Pour assurer la sécurité des threads sur iOS, les mécanismes principaux suivants sont utilisés:

1. Mutex (mutual exclusion):

   • pthread_mutex_t: API de bas niveau en C de POSIX.
   • NSLock: enveloppe orientée objet autour des primitives de verrouillage, partie de Foundation.
   • NSRecursiveLock: Permet un verrouillage récursif par le même thread.

   import Foundation
   
   let lock = NSLock()
   var ressourcePartagée = 0
   
   func modifierRessourcePartagée() {
       lock.lock()
       // Section critique
       ressourcePartagée += 1
       lock.unlock()
   }
   

2. Spin Lock:

   • OSSpinLock: obsolète et non recommandée en raison de problèmes de priorités et de consommation CPU excessive en attente prolongée. Remplacée par os_unfair_lock.
   • os_unfair_lock: remplacement plus efficace de OSSpinLock, partie de os.xnu.

   import os.lock
   
   var unfairLock = os_unfair_lock()
   var autreRessource = 0
   
   func mettreAJourRessource() {
       os_unfair_lock_lock(&unfairLock)
       // Section critique
       autreRessource += 1
       os_unfair_lock_unlock(&unfairLock)
   }
   

3. Sémaphore:

   • DispatchSemaphore: sémaphore de Grand Central Dispatch (GCD). Contrôle l'accès à une ressource via un compteur.

   import Foundation
   
   let semaphore = DispatchSemaphore(value: 1) // Compteur = 1 (équivalent à un mutex)
   var ressourceLimitée = 0
   
   func accéderRessourceLimitée() {
       semaphore.wait() // Diminue le compteur, bloque si <= 0
       // Section critique
       ressourceLimitée += 1
       semaphore.signal() // Augmente le compteur
   }
   

4. File d'attente concurrente avec tâches de barrière:

   • Utilisation d'une file d'attente concurrente en GCD pour lecture et écriture. La lecture s'effectue en parallèle (async), l'écriture de manière exclusive (sync(flags: .barrier)).

   import Foundation
   
   let fileAttenteConcurrente = DispatchQueue(label: "com.exemple.fileAttenteConcurrente", attributes: .concurrent)
   var tableauProtégé: [Int] = []
   
   func ajouterItem(_ item: Int) {
       fileAttenteConcurrente.sync(flags: .barrier) {
           // Tâche avec le drapeau .barrier exécutée de manière exclusive
           tableauProtégé.append(item)
       }
   }
   
   func lireTableau() -> [Int] {
       var copieTableau: [Int] = []
       fileAttenteConcurrente.sync {
           // Tâche synchrone normale (lecture) pouvant être parallèle à d'autres lectures
           copieTableau = tableauProtégé
       }
       return copieTableau
   }
   

5. Opérations atomiques:

   • Opérations de bas niveau garantissant l'atomicité (exécutées comme une seule unité, sans interruption). Utilisées pour des types de données simples (entiers, pointeurs).

   import Darwin // Pour certaines fonctions atomiques, comme OSAtomic...
   
   var compteurAtomic: Int32 = 0
   
   func incrementerCompteurAtomic() -> Int32 {
       // Exemple d'opération atomique
       return OSAtomicIncrement32(&compteurAtomic)
   }
   

   • En Swift, il existe des types expérimentaux Atomic<Value> dans swift-atomics.

6. Sanitiseur de threads (Thread Sanitizer):

   • Outil de débogage qui détecte les conditions de course (data races) lors de l'exécution de l'application. Activé dans le schéma de compilation Xcode (Edit Scheme -> Run -> Diagnostics -> Thread Sanitizer).

Le choix du mécanisme dépend de la tâche:

• Accès exclusif simple: NSLock, DispatchSemaphore(value: 1), os_unfair_lock.
• Verrouillage récursif: NSRecursiveLock.
• Lecture/écriture: File d'attente concurrente avec .barrier.
• Restriction d'accès (piscine de ressources): DispatchSemaphore (avec compteur > 1).
• Compteurs/falgs simples: Opérations atomiques (si applicable et si une performance maximale est requise, avec précaution).

Évitez:

• OSSpinLock.
• L'utilisation de verrous globaux sans nécessité.
• L'optimisation prématurée avec des primitives de bas niveau sans compréhension de leur fonctionnement.