Blog - How ARC works — Automatic Reference Counting

ARC (Automatic Reference Counting) is the memory model in Objective-C and for classes in Swift: an object lives as long as something holds a strong reference to it.

Reference count

Each object has a count $r$.

• strong assignment: $r \leftarrow r + 1$
• end of a strong reference’s lifetime: $r \leftarrow r - 1$
• when $r = 0$ → deinit / dealloc, memory returns to the system

The compiler inserts retain / release (or equivalents) — it is not a heap-scanning garbage collector.

Strong, weak, unowned

• strong (default) — owner; keeps the object alive.
• weak — does not increment $r$; becomes nil when the object is freed.
• unowned — does not increment $r$; you assert the object still lives (crash otherwise).

Retain cycles

Classic leak:

$$A \xrightarrow{strong} B \xrightarrow{strong} A$$

Then $r_A \ge 1$ and $r_B \ge 1$ forever. Fix: one side weak (e.g. delegate), or unowned when lifetime is guaranteed.

In Swift closures:

someAsync { [weak self] in
  guard let self else { return }
  self.update()
}

Without [weak self], the closure often retains self → a cycle with its owner.

ARC ≠ GC

That is why ARC fits iOS UI well: no surprise GC pauses, but cycles are your job.

Autorelease (ObjC)

Historically, an object can enter an autorelease pool and receive release later (e.g. end of the run loop). ARC still cooperates; in tight loops @autoreleasepool { ... } can prevent temporary-object buildup.

Takeaway

ARC is simple on the happy path and demanding on object graphs. Rule of thumb: one strong ownership path, break cycles with weak, especially for delegates and closures.