0Pricing
Swift Academy · Leçon

Main Thread Checker et blocages

Détecter le travail d’interface exécuté sur des threads d’arrière-plan et résoudre les blocages du thread principal.

Main Thread Checker et blocages est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Vérificateur du thread principal

Le vérificateur du thread principal (MTC) est un outil de diagnostic de Xcode qui signale à l’exécution les appels aux API UIKit/AppKit effectués depuis des threads d’arrière-plan.

// Enabled by default in Xcode Debug scheme:
// Product → Scheme → Edit → Diagnostics → ☑ Main Thread Checker
// Violating calls log a purple runtime warning in Xcode

Violations courantes de MTC

La mise à jour de l’interface utilisateur depuis des gestionnaires de fin d’exécution ou des files d’attente d’arrière-plan compte parmi les violations les plus fréquentes.

URLSession.shared.dataTask(with: url) { data, _, _ in
  self.label.text = "Done"  // VIOLATION: background thread
}.resume()
// Fix:
DispatchQueue.main.async { self.label.text = "Done" }

MTC avec async/await

Annoter une classe ou une fonction avec @MainActor garantit que toutes ses méthodes s’exécutent sur le thread principal.

@MainActor
final class ProfileViewModel: ObservableObject {
  @Published var name = ""
  func load() async {
    name = try? await fetchName()  // always on main thread
  }
}

Que sont les blocages ?

Un blocage survient lorsque le thread principal est bloqué trop longtemps, ce qui rend l’application non réactive. Le mécanisme de surveillance d’iOS met fin aux applications qui se bloquent au lancement (>20 s) ou après une action utilisateur.

// Common causes:
// - Synchronous network calls on main thread
// - Heavy computation blocking main run loop
// - Deadlocks between DispatchQueues

Modèle Hangs d’Instruments

L’instrument Hangs de Xcode 14 et versions ultérieures enregistre les événements de blocage avec des traces de pile complètes afin de diagnostiquer le blocage du thread principal.

// Instruments → Hangs template
// Shows hang duration (ms), call stack, and responsible frame
// Look for synchronous I/O or heavy loops

Vérificateur du thread principal dans les tests

MTC se déclenche également pendant les tests d’interface utilisateur. Configurez-le dans le schéma de test pour détecter les violations lors des parcours automatisés de l’interface utilisateur.

// XCTestScheme Diagnostics → ☑ Main Thread Checker
// UI test violation = instant fail in CI

Rapports de blocage de MetricKit

MetricKit recueille les rapports de blocage des applications en production dans MXHangDiagnosticPayload.

func didReceive(_ payloads: [MXDiagnosticPayload]) {
  payloads.compactMap { $0.hangDiagnostics }.flatMap { $0 }.forEach {
    print($0.callStackTree)
  }
}

Détecter les blocages avec Instruments

Enregistrez une trace et recherchez les intervalles pendant lesquels le thread principal s’exécute alors que le lien d’affichage ne se déclenche pas (images perdues).

// Time Profiler: look for long CPU bursts on main thread
// Core Animation: FPS drops to 0 during hang
// Hangs instrument: highlights exact frames where hang occurred

Corrections asynchrones des blocages courants

Déplacez le travail gourmand en CPU hors du thread principal avec Task.detached ou async let.

// HANG:
let processed = heavyProcessing(image)  // blocks main thread
// FIX:
let processed = await Task.detached(priority: .userInitiated) {
  heavyProcessing(image)
}.value

Éviter les API synchrones sur le thread principal

Remplacez les entrées-sorties synchrones de fichiers et les appels réseau par leurs équivalents asynchrones, ou déplacez-les vers une file d’attente d’arrière-plan.

// HANG: synchronous file read on main thread
let data = try! Data(contentsOf: largeFileURL)
// FIX:
let data = try await Task.detached { try Data(contentsOf: largeFileURL) }.value

Boucle d’exécution principale et minuteries

Les opérations longues dans la boucle d’exécution principale (dans les rappels de RunLoop.main) provoquent également des blocages. Déplacez les calculs hors de la boucle principale.

// AVOID: heavy work in main-thread timer callback
Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { _ in
  processAllItems()  // slow!
}
// PREFER: dispatch to background
Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { _ in
  Task.detached { processAllItems() }
}

Vérification rapide

Que garantit l’ajout de @MainActor à une classe concernant les appels à ses méthodes ?

Récapitulatif de la leçon

Activez le vérificateur du thread principal dans le schéma de débogage pour détecter les violations liées à l’utilisation de l’interface utilisateur depuis l’arrière-plan. Utilisez @MainActor sur les ViewModels et les vues. Déplacez le travail lourd hors du thread principal avec Task.detached ou des files d’attente d’arrière-plan. Utilisez l’instrument Hangs et MXHangDiagnosticPayload de MetricKit pour diagnostiquer les blocages réels.

Questions Fréquemment Posées

La leçon « Main Thread Checker et blocages » est-elle gratuite ?

Oui — le texte complet de « Main Thread Checker et blocages » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Main Thread Checker et blocages » ?

Détecter le travail d’interface exécuté sur des threads d’arrière-plan et résoudre les blocages du thread principal. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Main Thread Checker et blocages » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Fondamentaux d’Instruments : Time Profiler
  2. Instruments Allocations et Leaks
  3. Main Thread Checker et blocages
  4. Optimiser les chemins critiques : COW, inlining et spécialisation
← Retour à Swift Academy