ARC Fundamentals

ARC (Automatic Reference Counting) is Apple's memory management system for Objective-C and Swift. It automatically handles object lifecycle management by injecting memory management code during compilation, reducing manual memory management complexity and errors.

Compile-Time Operations

1. Reference Counting Operations Injection

The compiler inserts retain and release operations at appropriate locations. Retain increments an object's reference count, while release decrements it.

// Original code
MyObject *instance = [[MyObject alloc] init]; // Reference count: 1
instance = nil; // Reference count: 0, triggers dealloc

// ARC-injected code
MyObject *instance = [[MyObject alloc] init];
[instance retain]; // Increment reference count
[instance release]; // Decrement when set to nil

2. Reference Counting Optimization

The compiler optimizes reference counting operations by merging or eliminating redundant retain/release calls.

MyObject *objA = [[MyObject alloc] init];
MyObject *objB = objA; // No additional retain needed for aliasing

3. Autorelease Pool Management

For methods returning objects (like factory methods), the compiler inserts autorelease calls for delayed release.

+ (instancetype)createInstance {
    return [[[self alloc] init] autorelease];
}

Autorelease adds objects to the current autorelease pool, delaying release until the pool drains (typically at event loop end).

4. Dealloc Method Generation

The compiler generates or enhances dealloc methods to release instance variables.

- (void)dealloc {
    [_title release];
    [super dealloc];
}

5. Memory Rule Validation

ARC validates memory management rules during compilation, ensuring proper ownership transfers and issuing warnings for violations.

Runtime Operations

1. Reference Count Management

Runtime executes compiler-inserted retain/release operations. When reference count reaches zero, dealloc is called.

MyObject *item = [[MyObject alloc] init]; // retainCount: 1
[item retain]; // retainCount: 2
[item release]; // retainCount: 1
[item release]; // retainCount: 0, dealloc invoked

2. Autorleease Pool Handling

Autoreleased objects are added to current pools, which drain at block end, releasing contained objects.

@autoreleasepool {
    MyObject *temp = [[[MyObject alloc] init] autorelease];
    // Released when pool drains
}

3. Circular Reference Resolution

Weak references break retain cycles without increasing reference counts. Weak pointers auto-nil when objects deallocate.

@interface Controller : NSObject
@property (nonatomic, weak) id target;
@end

4. Dynamic Memory Management

ARC performs dynamic memory management during execution, handling allocation and deallocation based on actual usage.

ARC Implementation Details

ARC combines compile-time and runtime mechanisms. Instead of using Objective-C message passing for retain/release/autorelease, ARC calls underlying C functions for better performance since these operations occur frequently.

ARC manages object lifetimes by inserting retain/release at appropriate points: method-created objects get releases with in methods, while instance variables release in dealloc.

The system checks retainCount during each runloop iteration. Objects with zero retainCount get deallocated.

Unsafe Unretained References

__unsafe_unretained creates non-zeroing weak references. Unlike __weak, these become dangling pointers when objects deallocate. __unsafe_unretained offers better performance than __weak since it avoids nil-setting overhead, making it suitable for C interoperability and performance-critical scenarios where object lifetimes are certain.

Autorelease Pool Implementation

Autorelease pools use stack structures in memory. New pools push onto the stack top. Autoreleased objects join the current thread's top pool. Pool drainage pops stacks and releases all contained objects.

iOS creates numerous pools during execution, organized as LIFO stacks. The autoreleasepool mechanism uses three core functions: objc_autoreleasepoolPush, objc_autoreleasepoolPop, and objc_autorelease for push, pop, and object addition operations respectively.