【原】iOS开发进阶(唐巧)读书笔记(二)

第三部分：iOS开发底层原理

一、Objective-C对象模型

1.1 isa指针

NSObject.h部分代码：

NS_ROOT_CLASS
@interface NSObject <NSObject> {
    Class isa;
}

objc.h部分代码：

typedef struct objc_class *Class;
typedet struct objc_object {
    Class isa;
} *id;

每一个对象都有一个名为isa的指针，指向该对象的类

isa指针指向流程图以下：

若是把类当作一个C语言的结构体(struct)，isa指针就是这个结构体的第一个成员变量，类的其余成员变量依次排列在结构体中

排列顺序：
| 1 | isa指针 |
| --- | --- |
| 2 | NSObject的成员变量 |
| 3 | NSObject子类的成员变量 |
| 4 | NSObject子类的子类的成员变量 |
| ... | ... |
| n-1 | 父类的成员变量 |
| n | 类自己的成员变量 |

一个简单的继承的实例代码：

@interface Father : NSObject {
    int _father;
}

@end

@implementation Father
@end

@interface Child : Father {
    int _child;
}

@end

@implementation Child
@end

在Xcode中，咱们看到以下截图，这个结构与上面说的一致

由于对象在内存中的排布能够当作一个结构体，该结构体的大小并不能动态变化，因此没法在运行时动态地给对象增长成员变量。

对象的方法定义都保存在类的可变区域中。
在下面的 Objective-C 1.0 中，咱们能够看到方法的定义列表是一个名为 methodLists 的指针
经过修改指针指向的指针的值，就能够动态的为某一个类增长成员方法，这也是 Category 实现的原理

Objective-C 1.0 objc_class代码

struct objc_class {
    Class isa OBJC_ISA_AVAILABILITY;
#if !__OBJC2__
    Class super _class
    const char *name
    long version
    long info
    long instance_size
    struct objc_ivar_list *ivars
    struvt objc_method_list **methodLists
    struct objc_cache *cache
    struct objc_protocol_list *protocols
#endIf
} OBJC2_UNAVAILABLE

1.2 动态建立对象

#import <objc/runtime.h>

...

- (void)dynamicCreateClass {
    // 建立一个名为CustomView的类，它是UIView的子类
    Class newClass = objc_allocateClassPair([UIView class], "CustomView", 0);
    // 为这个类增长一个report的方法
    class_addMethod(newClass, @selector(report), (IMP)ReportFunction, "v@:");
    // 注册该类
    objc_registerClassPair(newClass);
    
    // 建立一个newClass的实例对象
    id instanceOfNewClass = [[newClass alloc] init];
    // 调用report方法
    [instanceOfNewClass performSelector:@selector(report)];
}

void ReportFunction(id self, SEL _cmd) {
    NSLog(@"This object is %p", self);
    NSLog(@"Class is %@, and super is %@", [self class], [self superclass]);
    Class currentClass = [self class];
    for (int i = 1; i < 5; i++) {
        NSLog(@"Following the isa pointer %d times gives %@ = %p", i, currentClass, currentClass);
        // 获取对象的isa指针所指向的对象
        currentClass = object_getClass(currentClass);
    }
    NSLog(@"NSObject class is %@ = %p", [NSObject class], [NSObject class]);
    NSLog(@"NSObject meta class is %@ = %p", object_getClass([NSObject class]), object_getClass([NSObject class]));
}

代码关键点：

1. import runtime 相关的头文件：objc/runtime.h。
2. 使用 objc_allocateClassPair 方法建立新的类。
3. 使用 class_addMethod 方法来给类增长新的方法。
4. 使用 objc_registerClassPair 方法来注册新的类。
5. 使用 objc_getClass 方法来获取对象的isa指针指向的对象。

1.3 方法交换（Method Swizzling）API说明

Objective-C提供了如下API来动态替换类方法或实例方法的实现：

• class_replaceMethod 替换类方法的定义

class_replaceMethod(Class  _Nullable __unsafe_unretained cls, SEL  _Nonnull name, IMP  _Nonnull imp, const char * _Nullable types)

• method_exchangeImplementations 交换两个方法的实现

method_exchangeImplementations(Method  _Nonnull m1, Method  _Nonnull m2)

• method_setImplementation 设置一个方法的实现

method_setImplementation(Method  _Nonnull m, IMP  _Nonnull imp)

比较：

• class_replaceMethod 当类中没有找到要替换的原方法时，该方法会调用 class_addMethod 来为类增长一个新的方法，也正由于这样，class_replaceMethod 在调用时须要传入 type 参数，而 method_exchangeImplementations 和 method_setImplementation 都不须要
• method_exchangeImplementations 内部实现是获取到两个方法的实现，而后进行互换

文档以下图：

使用场景：

• class_replaceMethod 当须要替换的方法有可能不存在时，能够考虑使用该方法。
• method_exchangeImplementations 当须要交换两个方法的实现时使用。
• method_setImplementation 是最简单的用法，当仅仅须要为一个方法设置其实现方式时使用。

二、Tagged Pointer 对象

2.1 原有系统的问题

32位程序过渡到64位存在的问题：

• 问题一：内存翻倍。
  在iOS数据类型中，不少数据类型所占内存都是根据CPU的位数决定的。那么，当程序从32位程序过渡到64位时，这些数据类型的内存就会翻倍。以下图所示：
  
• 问题二：效率问题。
  为了存储和访问一个NSNumber对象，咱们须要在堆上为其分配内存，另外还要维护它的引用计数，管理它的生命周期。这些都给程序增长了额外的逻辑，形成运行效率上的损失，

2.2 Tagged Pointer 介绍

Tagged Pointer就是为了解决上述问题提出的。
原理：将一个对象指针拆分为两部分。以下图：

引入后，内存变化以下图：

特色：

1. 专门用来存储小的对象，例如 NSNumber 和 NSDate
2. 指针的值再也不是地址了，而是真正的值。因此，实际上它再也不是一个对象了，它只是一个披着对象’皮‘的普通变量而已。因此，它的内存并不存储在堆中，也不须要 malloc 和 free
3. 在内存读取上有着之前3倍的效率，建立时比以前快106倍

注：Tagged Pointer 并非真正的对象，而是一个伪对象，没有 isa 指针

2.2 64位下 isa 指针优化

32位环境：

对象的引用计数都保存在一个外部表中。

Retain 操做包含以下的5个步骤：

1. 获取全局的记录引用计数的 hash 表。
2. 为了线程安全，给该 hash 表加锁。
3. 查找到目标对象的引用计数值。
4. 将该引用计数值加1，写回 hash 表。
5. 给该 hash 表解锁。

为了线程安全，须要对 hash 表进行加锁，从性能上看是很是差的。

64位环境：

isa指针是64位。每一个bit位含义以下图:

bit位	变量名	意义
1 bit	indexed	0 表示普通的isa，1 表示 Tagged Pointer
1 bit	has_assoc	表示对象是否有过 associated 对象，若是没有，在析构释放内存时能够更快
1 bit	has_cxx_dtor	表示该对象是否有 C++ 或 ARC 的析构函数，若是没有，在析构释放内存时能够更快
30 bit	shiftcls	类的指针
9 bit	magic	其值固定为 0xd2，用于在调试时分辨对象是否未完成初始化
1 bit	weakly_referenced	表示该对象是否有过 weak 对象，若是没有，在析构释放内存时能够更快
1 bit	deallocating	表示该对象是否正在析构
1 bit	has_sidetable_rc	表示该对象的引用计数值是否大到没法直接在 isa 中保存
19 bit	extra_rc	表示该对象超过 1 的引用计数值，例如，若是该对象的引用计数是6，则 extra_rc 的值为5

extra_rc 的19位 bit 用来保存对象的引用计数，这样对引用计数的操做只须要修改这个职责便可。

Retain 操做包含以下的5个步骤：

1. 检查 isa 指针上面的标记位，看引用计数是否保存在 isa 变量中，若是不是，则使用之前的步骤，不然执行第2步。
2. 检查当前对象是否正在释放，若是是，则不作任何事情。
3. 增长该对象的引用计数，可是并不立刻写回到 isa 变量中。
4. 检查增长后的引用计数的值是否可以被19位表示，若是不是，则切换为之前的办法，不然执行第5步。
5. 进行一个原子的写操做，将 isa 的值写回。

三、block 对象模型

3.1 定义：

在苹果的 llvm 项目的开源代码(https://llvm.org/svn/llvm-project/compiler-rt/tags/Apple/Libcompiler_rt-10/BlocksRuntime/Block_private.h)中，咱们能够看到 block 的数据结构定义，以下图：

对应的结构体定义以下：

struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};

struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables */
};

组成 block 实例的6个部分：

1. isa 指针，全部对象都有该指针，用于实现对象的相关的功能。
2. flags 用于按 bit 位表示一些 block 的附加信息，在后面介绍的 block copy 的实现代码中能够看到该变量的使用。
3. reserved 保留变量。
4. invoke 函数指针，指向具体的 block 实现的函数调用地址。
5. descriptor 表示该 block 的附加描述信息，主要是 size 的大小，以及 copy 和 dispose 函数的指针。
6. variable capture 过来的变量，block 可以访问它外部的局部变量，就是由于将这些变量（或变量的地址）复制到告终构体中。

3.2 分类：

block 的类型：

1. _NSConcreteGlobalBlock 全局的静态 block，不会访问任何外部变量。
2. _NSConcreteStackBlock 保存在栈中的 block，当函数返回时会被销毁。
3. _NSConcreteMallocBlock 保存在堆中的 block，当引用计数为 0 时会被销毁。

注：用 clang 分析 block 实现

clang 提供了一个命令，能够将 Objective-C 的源码改写成C语言。
命令是：clang -rewrite-objc block.c

3.2.1 NSConcreteGlobalBlock 类型的 block 的实现

建立一个名字为 block1.c 的源文件，文件实现：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    ^{ printf("Hello, World!\n"); } ();
    return 0;
}

在命令行中输入 clang -rewrite-objc block1.c，便可在目录中看到 clang 输出了一个名为 ”block1.cpp” 的文件，这个文件就是 block 在C语言中的实现。
关键代码引用以下：

...
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
...
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
 printf("Hello, World!\n"); }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, char const *argv[])
{
    ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)) ();
    return 0;
}

代码中，__main_block_impl_0 就是该 block 的实现，从中咱们能够看出：

1. 一个 block 实际是一个对象，它主要由一个 isa、一个 impl 和一个 descriptor 组成。
2. 因为这里没有开启 ARC，因此咱们看到 isa 的指向仍是 _NSConcreteStackBlock。但在开启 ARC 时，block 应该是 _NSConcreteGlobalBlock 类。
3. impl 是实际函数指针，本例中，它指向 __main_block_func_0。这里的 impl 至关于以前提到的 invoke 变量，只是 clang 编译器对变量的命名不同而已。
4. descriptor 是用于描述当前这个 block 的附加信息的，包括结构体的大小，须要 capture 和 dispose 的变量列表等。
   结构体大小须要保存到缘由是，每一个 block 会 capture 一些变量，这里变量会加到 __main_block_impl_0 这个结构体中，使其体积变大。

具体文件见：https://github.com/AlonerOwl/OC_Block/tree/master/NSConcreteGlobalBlock

3.2.2 NSConcreteStackBlock 类型的 block 的实现

建立一个名字为 block1.c 的源文件，文件实现：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    int a = 100;
    void (^block2)(void) = ^{ // block 实现
        printf("%d\n", a);
    };
    block2();
    
    return 0;
}

clang 后：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy

        printf("%d\n", a);
    }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, char const *argv[]) {
    int a = 100;
    void (*block2)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
    ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);

    return 0;
}

在本例中，咱们能够看到：

1. 本例中，isa 指向 _NSConcreteStackBlock，说明这是一个分配在栈上的实例。
2. __main_block_impl_0 中增长一个变量 a，在 block 中引用的变量 a，实际是在声明 block 时，被复制到 __main_block_impl_0 结构体中的那个变量 a。
3. __main_block_impl_0 中因为增长一个变量 a，因此结构体变大了，该结构体大小被写在了 __main_block_desc_0 中。

咱们修改上面的源码，在变量前面增长 __block 关键字：

#include <stdio.h>

int main(int argc, char const *argv[]) {
    __block int i = 1024;
    void (^block2)(void) = ^{ // block 实现
        printf("%d\n", i);
        i = 1023;
    };
    block2();
    
    return 0;
}

clang 后，与以前差别至关大：

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

        printf("%d\n", (i->__forwarding->i));
        (i->__forwarding->i) = 1023;
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main(int argc, char const *argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
    void (*block2)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)block2)->FuncPtr)((__block_impl *)block2);

    return 0;
}

从代码中咱们能够看到：

1. 源码中增长了一个名为 __Block_byref_i_0 的结构体，用于保存咱们要 capture 而且修改的变量 i。
2. __main_block_impl_0 中引用的是 __Block_byref_i_0 的结构体指针，这样就能够起到修改外部变量的做用。
3. __Block_byref_i_0 的结构体带有 isa，说明它也是一个对象。
4. 咱们须要负责 __Block_byref_i_0 结构体相关的内存管理，全部 __main_block_desc_0 中增长了 copy 和 dispose 函数指针，用于在调用先后修改相应变量的引用计数。

具体文件见：https://github.com/AlonerOwl/OC_Block/tree/master/NSConcreteStackBlock

总结：
block 对于外部变量的使用，非 __block 修饰的变量，直接将其复制到 block 数据结构中来实现访问；__block 修饰的变量，复制这个变量的引用地址来实现访问的。

3.2.3 NSConcreteMallocBlock 类型的 block 的实现

NSConcreteMallocBlock 类型的 block 一般不会在源码中直接出现，只有当一个 block 被调用其 copy 方法的时候，系统才会将这个 block 复制到堆中，从而产生 NSConcreteMallocBlock 类型的 block。

注：在 ARC 开启的状况下，将只会存在 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 类型的 block。原来的 NSConcreteStackBlock 会被 NSConcreteMallocBlock 的进行替代。