0Pricing
Swift Academy · Aula

Instruments Allocations e Leaks

Rastreie alocações no heap e encontre vazamentos de memória e objetos zumbis.

Instruments Allocations e Leaks é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 4 aulas no total.

Instrumento Allocations

O instrumento Allocations acompanha cada alocação e desalocação na memória dinâmica, mostrando o crescimento da memória ao longo do tempo.

// Instruments → Allocations template
// Shows live bytes, allocation count, and transient objects

Análise do crescimento da memória dinâmica

Use o aplicativo e observe o gráfico Live Bytes. Um crescimento constante sem atingir um platô indica um vazamento de memória.

// Normal: allocations rise and fall as views appear/disappear
// Leak: allocations only grow, never released

Análise de gerações

Marque uma captura de uma geração antes e depois de um fluxo do usuário para ver quais objetos permaneceram inesperadamente.

// 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 released

Instrumento Leaks

O instrumento Leaks verifica periodicamente a memória dinâmica e identifica objetos alocados, mas inacessíveis (ciclos de retenção).

// Run Leaks alongside Allocations in the "Leaks" template
// Red bars in the timeline = leaked objects detected
// Click a bar to see the leaked object graph

Lendo o gráfico de vazamentos

O gráfico de objetos de vazamento mostra quais objetos mantêm referências uns aos outros em um ciclo, identificando a raiz do ciclo de retenção.

// Example cycle:
// ViewController → ViewModel → Closure → ViewController
// Instruments draws the reference edges visually

Detectando ciclos de retenção em fechamentos

O vazamento mais comum ocorre quando um fechamento captura self fortemente enquanto self mantém o fechamento.

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) }
  }
}

Instrumento VM Tracker

O VM Tracker mostra regiões de memória virtual e páginas modificadas. Uma pressão elevada de memória modificada faz o iOS encerrar o aplicativo.

// Instruments → "VM Tracker" in allocation instrument
// Look for: large __DATA dirty pages, high CG raster memory

Objetos zumbis

Ative Objetos zumbis no Instruments para detectar objetos liberados em excesso — eles são transformados em "zumbis" que registram quando são acessados.

// Instruments → Edit → Record Settings → Enable Zombie Objects
// Accessing a zombie prints: "*** -[MyObject method] sent to deallocated instance"

Capturas da memória dinâmica

Compare dois estados da memória dinâmica com "Captura da memória dinâmica" para encontrar objetos que sobrevivem entre as capturas — excelente para detectar vazamentos em controladores de visualização.

// After navigating to and from a screen twice:
// Heap should return to baseline
// Objects remaining in the diff = leaked view controllers or models

MetricKit para memória em produção

Use MXMetricPayload para coletar dados de memória e desempenho de usuários reais em produção.

import MetricKit
class AppDelegate: UIApplicationDelegate, MXMetricManagerSubscriber {
  func didReceive(_ payloads: [MXMetricPayload]) {
    payloads.forEach { print($0.memoryMetrics as Any) }
  }
}

Verificação rápida

O que um gráfico "Live Bytes" que cresce continuamente no instrumento Allocations indica?

Recapitulação da lição

Use Allocations para acompanhar o crescimento da memória dinâmica e as capturas de gerações. Use Leaks para detectar ciclos de retenção e visualizar o gráfico de objetos. Use Objetos zumbis para encontrar erros de liberação excessiva. Corrija os fechamentos com [weak self]. Use MetricKit para acompanhar a memória de usuários reais em produção.

Perguntas Frequentes

A aula “Instruments Allocations e Leaks” é grátis?

Sim — o texto completo de “Instruments Allocations e Leaks” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 4 aulas no total.

O que vou aprender em “Instruments Allocations e Leaks”?

Rastreie alocações no heap e encontre vazamentos de memória e objetos zumbis. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Swift Academy?

Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Instruments Allocations e Leaks”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Swift Academy?

Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Fundamentos do Instruments: Time Profiler
  2. Instruments Allocations e Leaks
  3. Main Thread Checker e travamentos
  4. Otimização de caminhos críticos: COW, inlining e especialização
← Voltar para Swift Academy