Instruments Allocations et Leaks
Suivre les allocations du tas et trouver les fuites mémoire ainsi que les objets zombies.
Instruments Allocations et Leaks est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.
Instrument Allocations
L’instrument Allocations suit chaque allocation et libération dans le tas, et affiche l’évolution de la mémoire au fil du temps.
// Instruments → Allocations template
// Shows live bytes, allocation count, and transient objectsAnalyser la croissance du tas
Utilisez votre application et observez le graphique Live Bytes. Une croissance régulière sans plateau indique une fuite mémoire.
// Normal: allocations rise and fall as views appear/disappear
// Leak: allocations only grow, never releasedAnalyser les générations
Marquez un instantané de génération avant et après un parcours utilisateur pour voir quels objets ont persisté de manière inattendue.
// Instruments toolbar → "Mark Generation"
// Perform action (e.g., open and close a screen)
// "Mark Generation" again
// Inspect objects in the new generation that weren't releasedInstrument Leaks
L’instrument Leaks analyse périodiquement le tas et identifie les objets qui sont alloués mais inaccessibles (cycles de rétention).
// Run Leaks alongside Allocations in the "Leaks" template
// Red bars in the timeline = leaked objects detected
// Click a bar to see the leaked object graphLire le graphe des fuites
Le graphe des objets présentant des fuites montre quels objets se retiennent mutuellement dans un cycle et permet d’identifier la racine du cycle de rétention.
// Example cycle:
// ViewController → ViewModel → Closure → ViewController
// Instruments draws the reference edges visuallyDétecter les cycles de rétention dans les fermetures
La fuite la plus courante survient lorsqu’une fermeture capture fortement self tandis que self détient la fermeture.
class MyVC: UIViewController {
var onComplete: (() -> Void)?
override func viewDidLoad() {
super.viewDidLoad()
// LEAK: closure captures self; self holds onComplete
onComplete = { self.dismiss(animated: true) }
// FIX:
onComplete = { [weak self] in self?.dismiss(animated: true) }
}
}Instrument VM Tracker
VM Tracker affiche les régions de mémoire virtuelle et les pages modifiées. Une forte pression liée à la mémoire modifiée pousse iOS à mettre fin à votre application.
// Instruments → "VM Tracker" in allocation instrument
// Look for: large __DATA dirty pages, high CG raster memoryObjets zombies
Activez Zombie Objects dans Instruments pour détecter les objets libérés excessivement : ils sont transformés en « zombies » qui consignent toute tentative d’accès.
// Instruments → Edit → Record Settings → Enable Zombie Objects
// Accessing a zombie prints: "*** -[MyObject method] sent to deallocated instance"Instantanés du tas
Comparez deux états du tas avec « Heap Shot » pour trouver les objets qui survivent entre les deux instantanés : c’est très utile pour détecter les fuites des contrôleurs de vue.
// After navigating to and from a screen twice:
// Heap should return to baseline
// Objects remaining in the diff = leaked view controllers or modelsMetricKit pour la mémoire en production
Utilisez MXMetricPayload pour recueillir les données de mémoire et de performances des utilisateurs réels en production.
import MetricKit
class AppDelegate: UIApplicationDelegate, MXMetricManagerSubscriber {
func didReceive(_ payloads: [MXMetricPayload]) {
payloads.forEach { print($0.memoryMetrics as Any) }
}
}Vérification rapide
Qu’indique un graphique « Live Bytes » qui augmente régulièrement dans l’instrument Allocations ?
Récapitulatif de la leçon
Utilisez Allocations pour suivre la croissance du tas et les instantanés de génération. Utilisez Leaks pour détecter les cycles de rétention et afficher le graphe des objets. Utilisez Zombie Objects pour détecter les erreurs de libération excessive. Corrigez les fermetures avec [weak self]. Utilisez MetricKit pour suivre la mémoire des utilisateurs réels en production.
Questions Fréquemment Posées
La leçon « Instruments Allocations et Leaks » est-elle gratuite ?
Oui — le texte complet de « Instruments Allocations et Leaks » 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 « Instruments Allocations et Leaks » ?
Suivre les allocations du tas et trouver les fuites mémoire ainsi que les objets zombies. 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 2 sur 4.
Combien de temps prend la leçon « Instruments Allocations et Leaks » ?
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
- Fondamentaux d’Instruments : Time Profiler
- Instruments Allocations et Leaks
- Main Thread Checker et blocages
- Optimiser les chemins critiques : COW, inlining et spécialisation