iOS中的内存管理

高地址
┌─────────────────────────────────────┐
│             栈区 (Stack)             │  ↓ 向低地址增长
│   局部变量、函数参数、返回地址           │
├─────────────────────────────────────┤
│                 ↕                   │
│            动态分配区                 │
│                 ↕                   │
├─────────────────────────────────────┤
│             堆区 (Heap)              │  ↑ 向高地址增长
│         动态分配的对象实例             │
├─────────────────────────────────────┤
│           全局/静态区 (BSS)           │
│       未初始化的全局变量和静态变量       │
├─────────────────────────────────────┤
│           数据区 (Data)              │
│       已初始化的全局变量和静态变量       │
├─────────────────────────────────────┤
│           常量区 (Rodata)            │
│            字符串常量等               │
├─────────────────────────────────────┤
│           代码区 (Text)              │
│            编译后的代码               │
└─────────────────────────────────────┘
低地址

// 值类型 - 栈上分配
struct Point {
    var x: Double
    var y: Double
}

var p1 = Point(x: 1.0, y: 2.0)  // 栈上分配
var p2 = p1                      // 完整拷贝，独立存储
p2.x = 5.0                       // 不影响p1

// 引用类型 - 堆上分配
class PointClass {
    var x: Double
    var y: Double
    init(x: Double, y: Double) {
        self.x = x
        self.y = y
    }
}

var pc1 = PointClass(x: 1.0, y: 2.0)  // 堆上分配
var pc2 = pc1                          // 共享引用
pc2.x = 5.0                            // pc1.x也变为5.0

protocol Shape {
    func area() -> Double
}

struct SmallShape: Shape {   // 8字节，内联存储，无堆分配
    var radius: Double
    func area() -> Double { return .pi * radius * radius }
}

struct LargeShape: Shape {   // 40字节，超出内联缓冲区，堆分配
    var a, b, c, d, e: Double
    func area() -> Double { return a * b }
}

let s1: Shape = SmallShape(radius: 5)    // 内联存储
let s2: Shape = LargeShape(a: 1, b: 2, c: 3, d: 4, e: 5)  // 堆分配

// 引用计数的基本操作（概念演示）
NSObject *obj = [[NSObject alloc] init];  // 引用计数 = 1
NSObject *obj2 = obj;                      // 引用计数 = 2 (ARC下自动retain)
obj2 = nil;                                // 引用计数 = 1 (ARC下自动release)
obj = nil;                                 // 引用计数 = 0，对象被销毁

union isa_t {
    struct {
        uintptr_t nonpointer        : 1;  // 是否为非指针isa
        uintptr_t has_assoc         : 1;  // 是否有关联对象
        uintptr_t has_cxx_dtor      : 1;  // 是否有C++析构函数
        uintptr_t shiftcls          : 33; // 类指针
        uintptr_t magic             : 6;  // 调试标识
        uintptr_t weakly_referenced : 1;  // 是否被弱引用
        uintptr_t deallocating      : 1;  // 是否正在释放
        uintptr_t has_sidetable_rc  : 1;  // 引用计数是否存储在侧表
        uintptr_t extra_rc          : 19; // 引用计数减1的值（arm64架构）
    } bits;
};

struct SideTable {
    os_unfair_lock slock;       // 锁，保证线程安全（早期 objc4 使用过 spinlock_t）
    RefcountMap refcnts;        // 引用计数哈希表
    weak_table_t weak_table;    // 弱引用表
};

class PureSwiftClass {
    var value: Int = 0
}

// ARC编译前
- (void)example {
    NSObject *obj = [[NSObject alloc] init];
    [self doSomething:obj];
}

// ARC编译后（伪代码）
- (void)example {
    NSObject *obj = [[NSObject alloc] init];  // retain count = 1
    [self doSomething:obj];
    [obj release];                             // 编译器自动插入
}

// __strong是默认修饰符，以下两种写法等价
NSObject *obj1 = [[NSObject alloc] init];
__strong NSObject *obj2 = [[NSObject alloc] init];

// 赋值时自动retain，超出作用域自动release
- (void)example {
    NSObject *obj = [[NSObject alloc] init];  // 引用计数 = 1
    self.property = obj;                       // 引用计数 = 2
}  // obj超出作用域，引用计数 = 1

NSObject *strongObj = [[NSObject alloc] init];
__weak NSObject *weakObj = strongObj;

NSLog(@"%@", weakObj);  // 输出对象信息

strongObj = nil;        // 对象被释放
NSLog(@"%@", weakObj);  // 输出 (null)，weakObj自动置nil

NSObject *strongObj = [[NSObject alloc] init];
__unsafe_unretained NSObject *unsafeObj = strongObj;

NSLog(@"%@", unsafeObj);  // 输出对象信息

strongObj = nil;          // 对象被释放
// 危险！unsafeObj仍然指向已释放的内存地址（野指针）
// NSLog(@"%@", unsafeObj);  // 可能崩溃

// 方法返回BOOL表示成功/失败，同时通过out参数输出错误详情
- (BOOL)doSomethingWithError:(NSError *__autoreleasing *)error {
    if (/* 发生错误 */) {
        *error = [NSError errorWithDomain:@"MyDomain" code:1 userInfo:nil];
        return NO;
    }
    return YES;
}

// 调用时
NSError *error;
if (![self doSomethingWithError:&error]) {
    NSLog(@"Error: %@", error);
}

class Person {
    var apartment: Apartment?
    deinit { print("Person deinit") }
}

class Apartment {
    var tenant: Person?  // 强引用导致循环引用
    deinit { print("Apartment deinit") }
}

var person: Person? = Person()
var apartment: Apartment? = Apartment()
person?.apartment = apartment
apartment?.tenant = person

person = nil      // Person不会被释放
apartment = nil   // Apartment不会被释放

class Apartment {
    weak var tenant: Person?  // 使用弱引用，打破循环
    deinit { print("Apartment deinit") }
}

func process() {
    let obj = SomeClass()  // 生命周期局限于函数内，且未被闭包捕获或存储到堆属性
    obj.value = 42         // 编译器证明不逃逸后，分配在栈上，零ARC开销
    print(obj.value)
}

func example() {
    let obj = SomeClass()   // retain count = 1
    let obj2 = obj          // 编译器分析后，消除冗余的retain
    process(obj)            // 当process为非逃逸调用时，消除参数传递的retain/release
    process(obj2)
    // 只在函数结束时执行一次release
}

struct OpaqueExistentialContainer {
    void* inlineBuffer[3];     // 24字节内联缓冲区
    TypeMetadata* type;        // 类型元数据指针（8字节）
    WitnessTable* witnessTable; // 见证表指针（8字节，每遵循一个协议多一个）
};

// 使用协议类型：每次调用都经过存在容器，大值类型触发堆分配
func drawShape(_ shape: Shape) { ... }

// 使用泛型约束：编译器特化为具体类型，零存在容器开销
func drawShape<T: Shape>(_ shape: T) { ... }

- (void)someMethod {
    NSObject *obj = [[NSObject alloc] init];  // 引用计数 = 1
    [self doSomething:obj];
    // 方法结束，obj引用计数归零，立即调用dealloc释放
}

- (NSString *)createString {
    // stringWithFormat:返回autorelease对象
    NSString *str = [NSString stringWithFormat:@"hello"];
    return str;  // 不能立即释放，调用者还要使用
}
// str会在autoreleasepool销毁时释放

// 调用方
NSArray *arr = [self createArray];

// 被调用方
- (NSArray *)createArray {
    return [[NSArray alloc] init];
}

// 1. createArray内部：对象引用计数为1
id obj = [[NSArray alloc] init];  // retainCount = 1

// 2. 返回前调用autorelease，对象加入自动释放池
objc_autorelease(obj);  // 稍后会-1

// 3. 调用方接收返回值后，需要retain来持有
arr = objc_retain(obj);  // retainCount = 2

// 4. 自动释放池drain时，执行之前的autorelease
// retainCount = 1，对象由arr持有

// 编译器检测到arr是strong变量，需要持有返回值
// 于是省略了autorelease/retain的配对操作，直接传递所有权

// 1. createArray内部：对象引用计数为1
id obj = [[NSArray alloc] init];  // retainCount = 1

// 2. 直接返回，不调用autorelease
// 3. 调用方直接接收所有权，不调用retain
arr = obj;  // retainCount仍为1，所有权直接转移

@autoreleasepool {
    for (int i = 0; i < 10000; i++) {
        NSString *str = [NSString stringWithFormat:@"Number: %d", i];
        // str被加入自动释放池
    }
    // 循环结束后，池中所有对象被释放
}

class AutoreleasePoolPage {
    magic_t const magic;               // 校验值，用于验证page完整性
    id *next;                          // 栈顶指针，指向下一个可存放对象的位置
    pthread_t const thread;            // 所属线程（每个线程有独立的autoreleasepool）
    AutoreleasePoolPage * const parent; // 父节点（双向链表）
    AutoreleasePoolPage *child;        // 子节点（双向链表）
    uint32_t const depth;              // 链表深度
    uint32_t hiwat;                    // high water mark，记录最大入栈数量
    
    // page的剩余空间用于存储autorelease对象指针
    // 每个page大小为4096字节（一个虚拟内存页）
};

AutoreleasePoolPage (4096 bytes):
┌─────────────────────────────────┐  ← page 起始地址
│  magic (16 bytes)               │
│  next                           │
│  thread                         │     成员变量区域
│  parent                         │     （约 56 字节）
│  child                          │
│  depth                          │
│  hiwat                          │
├─────────────────────────────────┤
│  POOL_BOUNDARY (nil)            │  ← 外层 @autoreleasepool 的哨兵
│  obj1 指针                       │
│  obj2 指针                       │     外层池管理的对象
│  obj3 指针                       │
├ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┤
│  POOL_BOUNDARY (nil)            │  ← 内层嵌套 @autoreleasepool 的哨兵
│  obj4 指针                       │     内层池管理的对象
│  ...                            │
│  (空闲空间)                      │  ← next 指针指向此处
└─────────────────────────────────┘

#define POOL_BOUNDARY nil

// @autoreleasepool { 展开后调用
void *objc_autoreleasePoolPush(void) {
    return AutoreleasePoolPage::push();
}

// } 结束时调用
void objc_autoreleasePoolPop(void *ctxt) {
    AutoreleasePoolPage::pop(ctxt);
}

┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│    Page 1    │◄──►│    Page 2    │◄──►│    Page 3    │
│   (已满)      │    │   (已满)     │    │  (当前page)   │
│              │    │              │    │   hotPage    │
└──────────────┘    └──────────────┘    └──────────────┘
                                              ↑
                                           next指针

id objc_autorelease(id obj) {
    return obj->autorelease();
}

// 简化的实现逻辑
inline id autorelease() {
    AutoreleasePoolPage *page = hotPage();
    if (page && !page->full()) {
        // 快速路径：直接添加到当前page
        return page->add(this);
    } else {
        // 慢速路径：需要创建新page或查找有空间的page
        return autoreleaseFullPage(this, page);
    }
}

id *add(id obj) {
    id *ret = next;    // 返回当前位置
    *next++ = obj;     // 存入对象，指针后移
    return ret;
}

// 子线程示例
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    @autoreleasepool {  // 子线程需要手动创建
        // 在子线程中创建autorelease对象
        NSString *str = [NSString stringWithFormat:@"background"];
    }  // 离开作用域时释放
});

// GCD会自动为block创建autoreleasepool，但不保证释放时机
// 如果需要控制内存峰值，仍应手动创建

RunLoop一次循环:
┌─────────────────────────────────────────────┐
│  kCFRunLoopEntry     → push autoreleasepool │
│                                             │
│  处理事件（Timer、Source、Observer...）        │
│                                             │
│  kCFRunLoopBeforeWaiting → pop + push pool  │  ← autorelease对象在此释放
│                                             │
│  kCFRunLoopExit      → pop autoreleasepool  │
└─────────────────────────────────────────────┘

// 不使用autoreleasepool
- (void)processWithoutPool {
    for (int i = 0; i < 10000; i++) {
        // stringWithFormat: 返回autorelease对象
        NSString *str = [NSString stringWithFormat:@"data_%d", i];
        [self process:str];
    }
    // 循环结束时，10000个对象仍在内存中
    // 要等到RunLoop休眠时才统一释放 → 内存峰值高
}

// 使用autoreleasepool
- (void)processWithPool {
    for (int i = 0; i < 10000; i++) {
        @autoreleasepool {
            NSString *str = [NSString stringWithFormat:@"data_%d", i];
            [self process:str];
        }  // 每次循环结束，局部pool drain，str立即释放
    }
    // 任意时刻只有1个对象在内存中 → 内存峰值低
}

func processImages(paths: [String]) {
    for path in paths {
        autoreleasepool {
            // UIImage内部可能产生autorelease对象
            let image = UIImage(contentsOfFile: path)
            let thumbnail = image?.resized(to: targetSize)
            saveThumbnail(thumbnail)
        }
    }
}

for i in 0..<10000 {
    let data = Data(count: 1024)  // ARC直接管理，作用域结束立即释放
    process(data)
}  // 不需要autoreleasepool

// 创建Dirty Memory的例子
let array = [Int](repeating: 0, count: 1000000)  // 分配后立即变为dirty
let image = UIImage(named: "large_image")
let decodedImage = image?.cgImage  // 解码后的图片数据是dirty memory

Memory Footprint = Dirty Memory + Compressed Memory

// Objective-C中，局部变量不会自动初始化
int count;           // 值是未定义的（垃圾值）
NSString *str;       // 可能是nil，也可能是垃圾指针

// Swift中，编译器强制检查
var count: Int      // 编译错误：变量必须初始化
var str: String?    // 可选类型会自动初始化为nil

// 立即释放 - 方法结束时释放，不经过autoreleasepool
NSObject *obj = [[NSObject alloc] init];

// 延迟释放 - 等待autoreleasepool销毁
NSString *str = [NSString stringWithFormat:@"hello"];

@autoreleasepool {        // push POOL_BOUNDARY_1
    NSString *a = ...;    // push a
    @autoreleasepool {    // push POOL_BOUNDARY_2
        NSString *b = ...; // push b
    }                      // pop到POOL_BOUNDARY_2，释放b
}                          // pop到POOL_BOUNDARY_1，释放a