Memutus Siklus Retain dalam Block

A retain cycle happens when two objects strongly reference each other. Neither's count can reach zero, so neither is ever freed — a memory leak ARC cannot break for you.

An Objective-C block captures the variables it uses, including self — and it captures them strongly by default. This is the number one source of cycles.

Here self owns the block (stored in a property), and the block strongly captures self. That mutual ownership leaks.

Break the cycle by capturing a weak reference to self. A weak reference does not increase the retain count.

The convention names the capture weakSelf using __weak typeof(self) so the type stays correct even if the class changes.

A weak reference becomes nil the instant the object deallocates. If the block runs after that, messages to weakSelf are silently ignored — but partial access can be inconsistent.

Inside the block, promote weakSelf to a temporary strong reference so it cannot vanish mid-execution.

Not every block leaks. If self does not own the block — for example a one-shot block passed to a method and not stored — capturing self strongly is fine and even safer.

The same rule applies to delegates: a delegate property should be weak so a view controller and its child do not retain each other.

Tools to hunt cycles:

• Instruments > Leaks flags leaked allocations
• Memory Graph Debugger in Xcode visualizes retain cycles
• Log in dealloc to confirm objects are freed

Ask: does self own this block, and does the block touch self? If both are yes, use weakSelf (plus a strongSelf guard for multi-step work).

You learned to break retain cycles:

• Blocks capture self strongly by default
• A cycle leaks when self owns a block that references self
• Use __weak typeof(self) weakSelf to break it
• Add a strongSelf guard for multi-step work
• Mark delegate properties weak

Instruments and the Memory Graph confirm your fixes.