ARC: o que é, princípio de funcionamento do Automatic Reference Counting no iOS

O que é ARC?

ARC (Automatic Reference Counting) é um mecanismo de gerenciamento de memória baseado em compilador introduzido pela Apple no Xcode 4.2 (2011) para Objective-C e herdado pelo Swift. Ao contrário do gerenciamento manual de memória (Manual Retain-Release, MRR), o ARC automatiza completamente as chamadas retain, release e autorelease, inserindo-as em tempo de compilação sem intervenção do desenvolvedor.

ARC não é um coletor de lixo. É análise estática com inserção dinâmica de código: o compilador analisa os tempos de vida dos objetos e coloca retain/release nos pontos onde os objetos são criados, copiados ou saem de escopo. O resultado é liberação determinística de memória: o objeto é removido exatamente quando não há mais referências apontando para ele, sem atrasos ou pausas.

De acordo com a WWDC 2011 Session 323, a transição de MRR para ARC reduziu os bugs de crash relacionados à memória em 70% nas aplicações da Apple. Os desenvolvedores pararam de equilibrar manualmente retain/release, eliminando toda uma classe de vazamentos e erros de double-free.

Como funciona o Automatic Reference Counting

Cada objeto na memória tem um contador de referências (retain count). Quando um objeto é criado, o contador é definido como 1. Quando uma nova referência strong aponta para o objeto — o contador aumenta (retain). Quando uma referência strong desaparece — o contador diminui (release). Ao chegar a zero, o objeto é imediatamente liberado.

O compilador Swift insere retain/release não em cada atribuição — ele usa análise estática para otimização. Por exemplo, se é garantido que um objeto não será usado após ser passado, o compilador pode pular um release/retain desnecessário. Esta otimização é chamada de ARC Optimization.

class Person {
    let name: String
    init(name: String) {
        self.name = name
        print("\(name) initialized (retain count: 1)")
    }
    deinit {
        print("\(name) deallocated")
    }
}

func testARC() {
    let p = Person(name: "Alice")  // retain count = 1
    let q = p                      // retain count = 2
    // q sai do escopo
    // retain count = 1
    // p sai do escopo
    // retain count = 0 → deinit
}

Este exemplo mostra como o ARC gerencia o contador: ao atribuir q = p, o contador aumenta; quando q sai de escopo, diminui. Quando a última referência strong desaparece, o desinicializador é chamado imediatamente. Nenhum coletor de lixo espera — a memória é liberada na hora.

ARC vs Garbage Collection: diferenças principais

ARC e Garbage Collection resolvem o mesmo problema — gerenciamento automático de memória — mas com abordagens fundamentalmente diferentes. A escolha entre eles define a arquitetura da linguagem: Swift (ARC) vs Java/Go (GC). Vamos ver as principais diferenças.

A troca fundamental: ARC fornece tempos de vida previsíveis e zero pausas, mas exige que o desenvolvedor entenda retain cycles e escolha weak/unowned corretamente. GC libera o desenvolvedor dessas preocupações, mas ao custo de pausas não determinísticas e uma thread adicional.

Strong, Weak e Unowned: qualificadores de referência no ARC

ARC define três tipos de qualificadores de referência, cada um afetando o contador e o ciclo de vida do objeto de forma diferente. Escolher o qualificador correto é a base do gerenciamento seguro de memória em Swift.

Strong

Strong é o qualificador padrão. Cada referência strong aumenta o retain count do objeto em 1. Enquanto existir pelo menos uma referência strong, o objeto permanece vivo. Todas as propriedades de classe e variáveis locais em Swift são strong por padrão. Referências strong criam uma relação de posse: o objeto A possui o objeto B.

Weak

Weak é uma referência que não aumenta o retain count. Um objeto pode ser liberado mesmo que uma referência weak aponte para ele. Após a liberação, a referência weak é automaticamente definida como nil. Referências weak são sempre declaradas como var com tipo opcional (?). São usadas para quebrar retain cycles, especialmente no padrão delegate.

Unowned

Unowned é uma referência não proprietária que, como weak, não aumenta o retain count. No entanto, uma referência unowned não é definida como nil após a liberação — acessar um objeto liberado causa um crash. Unowned é usado quando é garantido que o objeto vive pelo menos tanto quanto o objeto referenciador. Casos típicos são closures e relações pai-filho com tempo de vida garantido.

class Customer {
    let name: String
    var card: CreditCard?         // strong
    init(name: String) { self.name = name }
    deinit { print("\(name) deallocated") }
}

class CreditCard {
    let number: String
    unowned let customer: Customer   // unowned — não possui
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
    deinit { print("Card \(number) deallocated") }
}

var customer: Customer? = Customer(name: "Bob")
customer?.card = CreditCard(number: "1234", customer: customer!)
customer = nil
// Customer e CreditCard ambos liberados — sem retain cycle

Aqui CreditCard usa uma referência unowned para Customer. Customer possui o cartão (strong), e o cartão não possui o cliente (unowned). Quando Customer é liberado, ambos os objetos são liberados — nenhum retain cycle ocorre. Se card.customer fosse strong, o ciclo bloquearia a liberação.

Problemas comuns do ARC e suas soluções

Apesar da automação, ARC não é uma panaceia. Os desenvolvedores encontram vários problemas típicos que exigem compreensão do mecanismo interno de gerenciamento de memória.

Retain Cycle em Closures

As closures em Swift capturam variáveis externas por referência strong. Se uma closure é atribuída a uma propriedade de classe e captura self — ocorre um retain cycle: a classe retém a closure, a closure retém self. A solução é uma lista de captura com weak ou unowned.

class NetworkManager {
    var completionHandler: ((Data?) -> Void)?
    var data: Data?

    func fetchData() {
        completionHandler = { [weak self] result in
            guard let self else { return }
            self.data = result
            self.processResult()
        }
    }

    func processResult() { }
}

A lista de captura [weak self] cria uma referência weak para self dentro da closure. Isso quebra o potencial retain cycle. Guard let self garante que o objeto está vivo antes de executar o código. weak self é a prática padrão para closures assíncronas em Swift.

Desempenho de retain/release

Embora retain/release sejam operações leves, em loops intensivos os incrementos/decrementos frequentes do contador adicionam sobrecarga. Em Swift 5.9+, o compilador usa otimização que remove retain/release redundantes se o analisador provar que é seguro. No entanto, em Objective-C, retain/release ainda podem ser um gargalo em cenários de alta carga com milhões de chamadas por segundo.

Autorelease Pool

Autorelease Pool é um mecanismo de liberação diferida usado em Objective-C e alguns cenários Swift. Os objetos são colocados no pool e recebem release quando o pool é drenado. Em loops com muitos objetos temporários (por exemplo, análise JSON), criar um autoreleasepool personalizado reduz o pico de consumo de memória.