内存管理

1、何检测内存泄漏

Memory Leaks
Alloctions
Analyse
Debug Memory Graph
MLeaksFinder

泄露的内存主要有以下两种：

Laek Memory 这种是忘记Release 操作所泄露的内存。
Abandon Memory 这种是循环引用，无法释放掉的内存。

2、循环引用

实质：多个对象相互之间有强引用，不能释放让系统回收。

如何解决循环引用？

1、避免产生循环引用，通常是将strong引用改为 weak 引用。
在合适时机去手动断开循环引用。

在MRC 下，__block不会增加其引用计数，避免了循环引用
在 ARC 下，__block 修饰对象会被强引用，无法避免循环引用，需要手动解除。

NSTimer 循环引用属于相互循环使用
创建 NSTimer 作为其属性，由于定时器创建后也会强引用该控制器对象，那么该对象和定时器就相互循环引用了。
将定时器invalidate 并置为nil 即可

3、悬垂指针？野指针?

悬垂指针：指针指向的内存已经被释放了，但是指针还存在，这就是一个悬垂指针或者说迷途指针

野指针: 没有进行初始化的指针，其实都是野指针

retain,copy,assign,weak,_Unsafe_Unretain

Strong 修饰符表示指向并持有该对象，其修饰对象的引用计数会加 1。该对象只要引用计数不为 0 就不会被销毁。当然可以通过将变量强制赋值 nil 来进行销毁。

weak 修饰符指向但是并不持有该对象，引用计数也不会加 1。在 Runtime 中对该属性进行了相关操作，无需处理，可以自动销毁。weak 用来修饰对象，多用于避免循环引用的地方。weak 不可以修饰基本数据类型。

assign主要用于修饰基本数据类型，例如 NSInteger，CGFloat，存储在栈中，内存不用程序员管理。assign 是可以修饰对象的，但是会出现问题。

copy 关键字和 strong 类似，copy 多用于修饰有可变类型的不可变对象 NSString,NSArray,NSDictionary 上。

__unsafe_unretain 类似于weak ，但是当对象被释放后，指针已然保存着之前的地址，被释放后的地址变为僵尸对象，访问被释放的地址就会出问题，所以说他是不安全的。

__autoreleasing 将对象赋值给附有 __autoreleasing 修饰的变量等同于 ARC 无效时调用对象的 autorelease 方法,实质就是扔进了自动释放池。

4、深拷贝和浅拷贝集合类深拷贝如何实现

深拷贝：该对象是否复制一份，内容拷贝
浅拷贝：指针拷贝，

对于集合对象的内容复制仅仅是对对象本身，但是对象的里面的元素还是指针复制。要想复制整个集合对象，就要用集合深复制的方法，有两种：

（1）使用 initWithArray:copyItems:方法，将第二个参数设置为 YES 即可

NSDictionary * dct  = [[NSDictionary alloc] initWithDictionary:dicto copyItems:YES]

（2）将集合对象进行归档（archive）然后解归档（unarchive）：

 NSArray *trueDeepCopyArray = [NSKeyedUnarchiver unarchiveObjectWithData:[NSKeyedArchiver archivedDataWithRootObject:oldArr]]

5、Dealloc 的实现机制

一、Dealloc调用流程

1.首先调用 _objc_rootDealloc()
2.接下来调用 rootDealloc()
3.这时候会判断是否可以被释放，判断的依据主要有 5 个，判断是否有以上五种情况
NONPointer_ISA
weakly_reference
has_assoc
has_cxx_dtor
has_sidetable_rc
4-1.如果有以上五中任意一种，将会调用object_dispose()方法，做下一步的处理。
4-2.如果没有之前五种情况的任意一种，则可以执行释放操作，C 函数的 free()。
5.执行完毕。

- (void)dealloc {
    _objc_rootDealloc(self);
}

void _objc_rootDealloc(id obj)
{
    assert(obj);

    obj->rootDealloc();
}

inline void objc_object::rootDealloc(){
    if (isTaggedPointer()) return;  // fixme necessary?

    if (fastpath(isa.nonpointer  &&  
                 !isa.weakly_referenced  &&  
                 !isa.has_assoc  &&  
                 !isa.has_cxx_dtor  &&  
                 !isa.has_sidetable_rc))
    {
        assert(!sidetable_present());
        free(this);
    } 
    else {
        object_dispose((id)this);
    }
}

id object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

2.object_dispose() 调用流程。

1.直接调用 objc_destructInstance()。
2.之后调用 C 函数的 free()。

id 
object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);    
    free(obj);

    return nil;
}

3.objc_destructInstance() 调用流程

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        obj->clearDeallocating();
    }

    return obj;
}

1.先判断 hasCxxDtor，如果有 C++ 的相关内容，要调用 object_cxxDestruct() ，销毁 C++ 相关的内容。
2.再判断 hasAssocitatedObjects，如果有的话，要调用 object_remove_associations()，销毁关联对象的一系列操作。
3.然后调用 clearDeallocating()。
4.执行完毕。

4.clearDeallocating() 调用流程。

inline void 
objc_object::clearDeallocating()
{
    if (slowpath(!isa.nonpointer)) {
        // Slow path for raw pointer isa.
        sidetable_clearDeallocating();
    }
    else if (slowpath(isa.weakly_referenced  ||  isa.has_sidetable_rc)) {
        // Slow path for non-pointer isa with weak refs and/or side table data.
        clearDeallocating_slow();
    }

    assert(!sidetable_present());
}

1.先执行 sideTable_clearDellocating()。
2.再执行 weak_clear_no_lock,在这一步骤中，会将指向该对象的弱引用指针置为 nil。
3.接下来执行 table.refcnts.eraser()，从引用计数表中擦除该对象的引用计数。
4.至此为止，Dealloc 的执行流程结束。

7 、内存中的 5 大区

栈区（stack）：由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
堆区（heap）：一般由程序员分配释放，若程序员不释放，程序结束时可能由 OS 回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
全局区（静态区）（static）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后由系统释放。
文字常量区：常量字符串就是放在这里的。程序结束后由系统释放。
程序代码区：存放函数体的二进制代码。

8、内存管理方案

taggedPointer ：存储小对象如 NSNumber。深入理解 Tagged Pointer
NONPOINTER_ISA(非指针型的 isa):在 64 位架构下，isa 指针是占 64 比特位的，实际上只有 30 多位就已经够用了，为了提高利用率，剩余的比特位存储了内存管理的相关数据内容

散列表第一位的 0 或 1 代表是纯地址型 isa 指针，还是 NONPOINTER_ISA 指针。

第二位，代表是否有关联对象

第三位代表是否有 C++ 代码。

接下来 33 位代表指向的内存地址

接下来有弱引用的标记

接下来有是否 delloc 的标记....等等

复杂的数据结构，包括了引用计数表和弱引用表通过 SideTables()结构来实现的，SideTables()结构下，有很多 SideTable 的数据结构。而 sideTable 当中包含了自旋锁，引用计数表，弱引用表。 SideTables()实际上是一个哈希表，通过对象的地址来计算该对象的引用计数在哪个 sideTable 中

SideTables表在非嵌入式的 64 位系统中，有 64 张 SideTable 表

每一张 SideTable 主要是由三部分组成。自旋锁、引用计数表、弱引用表。

全局的引用计数之所以不存在同一张表中，是为了避免资源竞争，解决效率的问题。

引用计数表中引入了分离锁的概念，将一张表分拆成多个部分，对他们分别加锁，可以实现并发操作，提升执行效率

自旋锁：

自旋锁是“忙等”的锁。
适用于轻量访问。

引用计数表和弱引用表实际是一个哈希表，来提高查找效率。

9、内存布局

栈(stack):方法调用，局部变量等，是连续的，高地址往低地址扩展
堆(heap):通过 alloc 等分配的对象，是离散的，低地址往高地址扩展，需要我们手动控制
未初始化数据(bss):未初始化的全局变量等
已初始化数据(data):已初始化的全局变量等
代码段(text):程序代码

10、@dynamic

@dynamic 意味着编译器不会帮助我们自动合成 setter 和 getter 方法。我们需要手动实现、这里就涉及到 Runtime 的动态添加方法的知识点。

11、@autoreleasePool 的数据结构

简单说是双向链表，每张链表头尾相接，有 parent、child 指针 ;
每创建一个池子，会在首部创建一个 哨兵 对象,作为标记;
最外层池子的顶端会有一个next 指针。当链表容量满了，就会在链表的顶端，并指向下一张表。

objc_autoreleasePoolPush：把当前 next 位置置为 nil，即哨兵对象,然后 next 指针指向下一个可入栈位置， AutoreleasePool 的多层嵌套，即每次 objc_autoreleasePoolPush，实际上是不断地向栈中插入哨兵对象。
objc_autoreleasePoolPop: 根据传入的哨兵对象找到对应位置。给上次 push 操作之后添加的对象依次发送release 消息。回退next指针到正确的位置。

12、弱引用管理

添加 weak 变量:通过哈希算法位置查找添加。如果查找对应位置中已经有了当前对象所对应的弱引用数组，就把新的弱引用变量添加到数组当中；如果没有，就创建一个弱引用数组，并将该弱引用变量添加到该数组中。  当一个被 weak 修饰的对象被释放后，weak 对象怎么处理的？清除 weak 变量，同时设置指向为 nil。当对象被 dealloc 释放后，在 dealloc 的内部实现中，会调用弱引用清除的相关函数，会根据当前对象指针查找弱引用表，找到当前对象所对应的弱引用数组，将数组中的所有弱引用指针都置为 nil。

__weak 属性修饰的变量，如何实现在变量没有强引用后自动置为 nil ？

用的弱引用 - weak表。也是一张哈希表。
被 weak修饰的指针变量所指向的地址是 key ，所有指向这块内存地址的指针会被添加在一个数组里，这个数组是 Value。当内存地址销毁，数组里的所有对象被置为 nil。
weak修饰的指针变量，在指向的内存地址销毁后，会在 Runtime 的机制下，自动置为nil。