Swift Academy · Leçon

Cycles de rétention : causes et détection

Identifier les cycles de rétention entre objets et fermetures avec Instruments.

Cycles de rétention : causes et détection 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.

Bienvenue

Un cycle de rétention se produit lorsque deux objets ou plus détiennent des références fortes les uns vers les autres, empêchant ARC d’atteindre un compteur nul — ce qui provoque une fuite de mémoire.

Cycle simple entre deux objets

```swift class Owner { var pet: Pet? } class Pet { var owner: Owner? } var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p // Owner → Pet (strong) p?.owner = o // Pet → Owner (strong) o = nil; p = nil // Neither deinit called — cycle! ```

Cycle parent-enfant

```swift class Node { var children: [Node] = [] var parent: Node? // strong → cycle with parent } let root = Node() let child = Node() root.children.append(child) child.parent = root // cycle ```

Cycle de capture par une fermeture

```swift class ViewController { var onComplete: (() -> Void)? func setup() { onComplete = { // closure strongly captures self self.doWork() // ← cycle! } } } ```

Cycle du schéma délégué

```swift protocol TaskDelegate: AnyObject { func didFinish() } class Task { var delegate: TaskDelegate? // if strong → potential cycle } class Manager: TaskDelegate { var task = Task() init() { task.delegate = self } // Manager → Task → Manager } ```

Détecter avec Instruments

Utilisez Xcode Instruments → Fuites : 1. Exécutez l’application dans Instruments 2. Cliquez sur l’instrument Fuites 3. Les marques rouges indiquent les objets ayant fui 4. Affichez le détail pour voir le graphe des références Autre possibilité : définissez `deinit { print(...) }` et vérifiez s’il est appelé.

Détecter avec le graphe mémoire d’Xcode

Dans le débogueur d’Xcode : Débogage > Débogueur du graphe mémoire. Cliquez sur un objet ayant fui pour voir sa chaîne de références — le cycle apparaîtra sous la forme d’une boucle fermée dans le graphe.

Schémas de cycles courants

• Un délégué qui conserve fortement le délégué • Une fermeture capturant `self` fortement • Des références fortes bidirectionnelles parent-enfant • Un observateur de NotificationCenter conservant une fermeture qui capture l’objet courant • La cible de Timer étant `self` (forte)

Cycle de rétention d’un Timer

```swift class Poller { var timer: Timer? func start() { timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in self?.poll() // weak self breaks cycle } } deinit { timer?.invalidate() } } ```

Cycle de NotificationCenter

```swift class Listener { var token: NSObjectProtocol? init() { token = NotificationCenter.default.addObserver(forName: .UIApplicationDidBecomeActive, object: nil, queue: .main) { [weak self] _ in self?.refresh() } } deinit { NotificationCenter.default.removeObserver(token!) } } ```

Vérification rapide

Qu’est-ce qu’un cycle de rétention dans ARC ?

Récapitulatif

Points clés : • Cycles de rétention : références fortes mutuelles → aucune des deux instances n’est désallouée • Courants dans : les délégués, les fermetures, les liens bidirectionnels parent-enfant • Détectez-les avec Fuites d’Instruments ou le débogueur de graphe mémoire de Xcode • Corrigez-les avec des références `weak` ou `unowned` • Les minuteurs et NotificationCenter provoquent également des cycles — rompez-les avec `[weak self]` Ensuite : les références `weak` et `unowned`.

Questions Fréquemment Posées

La leçon « Cycles de rétention : causes et détection » est-elle gratuite ?

Oui — le texte complet de « Cycles de rétention : causes et détection » 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 « Cycles de rétention : causes et détection » ?

Identifier les cycles de rétention entre objets et fermetures avec Instruments. 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 « Cycles de rétention : causes et détection » ?

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

Comment ARC compte les références
Cycles de rétention : causes et détection
Références weak et unowned
Listes de capture des fermetures et [weak self]

← Retour à Swift Academy