iOS面试题（四）

1. OC 的消息机制

消息机制可以分为三个部分

1. 消息传递

• 当我么调用方法的时候，方法的调用都会转化为objc_msgSend这样来传递。

• 第一步会根据对象的isa指针找到所属的类(也就是类对象)

• 第二步，会根据类对象里面的catch里面查找。catch是个散列表，是根据@selector(方法名)来获取对应的IMP，从而开始调用

• 第三步，如果第二步没有找到，会继续查找到类对象里面的class_rw_t里面的methods(方法列表)，从而遍历，找到方法所属的IMP，如果查找到则会添加到catch表里面

• 第四步，如果第三部也没有找到，会根据类对象里面的superclass指针，查找super的catch,如果也是没有查找，会继续查找到superclass里面的class_rw_t里面的methods(方法列表)，从而遍历，找到方法所属的IMP，如果查找到则会添加到catch表里面

• 第五步，如果第四部还是没有查找到，此时会根据类的superclass,继续第四部操作

.......

• 第六步。如果一直查找到基类都没有找到响应的方法，则会进入动态解析里面

2. 动态解析

• 当消息传递，没有找到对应的IMP的时候，会进入的动态解析中

• 此时会根据方法是类方法，还是实例方法分别调用+(BOOL)resolveClassMethod:(SEL)sel、+(BOOL)resolveInstanceMethod:(SEL)sel

• 我们可以实现这两个方法，使用Runtime的class_addMethod来添加对应的IMP

• 如果添加后，返回true,没有添加则调用父类方法

• 注意：其实返回true或者false,结果都是一样的，再次掉消息传递步骤
  

3. 消息转发

• 如果我们没有实现动态解析方法，就会走到消息转发这里

• 第一步，会调用-(id)forwardingTargetForSelector:(SEL)aSelector方法，我们可以在这里，返回一个响应aSelector的对象。当返回不为nil时候，系统会继续再次走消息转发，继续查找对应的IMP

• 第二步，如果第一步返回nil或者self(自己),此时系统会继续走这里-(NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector,需要返回aSelector的一个签名

• 第三步，如果返回了签名，就会到这里-(void)forwardInvocation:(NSInvocation *)anInvocation,相应的我们可以根据anInvocation,可以获取到参数、target、方法名等，再次操作的空间就很多了，看你需求喽。此时我们什么都不操作也是没问题的，

• 注意：当我们是类方法的时候，其实我们可以将以上方法的-改为+，即可实现了类方法的转发

2.weak表是如何存储__weak指针的

• weak关键字，我们都知道，当对象销毁的时候，也会将指针赋值为nil，而weak的底层也是将指针和对象以键值对的形式存储在哈希表里面

• 当使用__weak修饰的时候，底层会调用id objc_storeWeak(id *location, id newObj)传递两个参数

        第一个参数为指针,第二个参数为所指向的对象

• 第二步，继续调用storeWeak(location, (objc_object *)newObj)

     1. 第一个参数是指针，第二个参数是对象的地址

     2. 再次方法里面会根据对象地址生成一个SideTables对象

• 第三步，调用id weak_register_no_lock(weak_table_t *weak_table, id referent_id, id *referrer_id, bool crashIfDeallocating)

     1. weak_table则为SideTables的一个属性，referent_id为对象，referrer_id则为那个弱引用的指针

     2. 在此里面会根据对象地址和指针生成一个weak_entry_t

• 第四步，会继续调用static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)

     重点：在此方法里面会根据对象 & weak_table->mask(表示weak表里面可以存储的大小减一，例如：表可以存储10个对象，那么mask就是9), 生成对应的index，如果index对应已经存储上对象，则会index++的方式找到未存储的对应，并将new_entry存储进去，储存在weak_table里的weak_entries属                    性里面

• 注意：当一个对象多个weak指针指向的时候，生成的也是一个entry，多个指针时保存在entry里面referrers属性里面

• 以下为简易的源码：

id
objc_storeWeak(id *location, id newObj)
{
return storeWeak
        (location, (objc_object *)newObj);
}
static id 
storeWeak(id *location, objc_object *newObj) {
// 根据对象生成新的SideTable
  SideTable *newTable = &SideTables()[newObj];
  newObj = (objc_object *)
  weak_register_no_lock(&newTable->weak_table, (id)newObj, location,  crashIfDeallocating);
}
id 
weak_register_no_lock(weak_table_t *weak_table, id referent_id, 
                      id *referrer_id, bool crashIfDeallocating){
  objc_object *referent = (objc_object *)referent_id;
  objc_object **referrer = (objc_object **)referrer_id;

// 根据对象和指针生成一个entry
  weak_entry_t new_entry(referent, referrer);
// 检查是是否该去扩容
  weak_grow_maybe(weak_table);
// 将新的entry 插入到表里面
  weak_entry_insert(weak_table, &new_entry);
}
static void weak_entry_insert(weak_table_t *weak_table, weak_entry_t *new_entry)
{
    weak_entry_t *weak_entries = weak_table->weak_entries;

    size_t begin = hash_pointer(new_entry->referent) & (weak_table->mask);
    size_t index = begin;
    size_t hash_displacement = 0;
while (weak_entries[index].referent != nil) {
        index = (index+1) & weak_table->mask;
if (index == begin) bad_weak_table(weak_entries);
        hash_displacement++;
    }
    weak_entries[index] = *new_entry;
    weak_table->num_entries++;
},>

weak_table的扩容，根据存储条数 >= 最大存储条数的3/4时，就会按照两倍的方式进行扩容，并且会将已经有的条目再次生成新的index(因为扩容后，weak_table的mask发生了改变)。进行保存

• 以下为简易的源码：

static void weak_grow_maybe(weak_table_t *weak_table)
{
size_t old_size = (weak_table->mask ? weak_table->mask + 1 : 0);
if (weak_table->num_entries >= old_size * 3 / 4) {
        weak_resize(weak_table, old_size ? old_size*2 : 64);
    }
}
static void weak_resize(weak_table_t *weak_table, size_t new_size)
{
size_t old_size = TABLE_SIZE(weak_table);
weak_entry_t *old_entries = weak_table->weak_entries;
// calloc 分配新的控件
    weak_entry_t *new_entries = (weak_entry_t *)
        calloc(new_size, sizeof(weak_entry_t));
    // mask 就是大小减一
    weak_table->mask = new_size - 1;
    weak_entry_t *entry;
    weak_entry_t *end = old_entries + old_size;
    for (entry = old_entries; entry < end; entry++) {
        if (entry->referent) {
           weak_entry_insert(weak_table, entry);
        }
    }
}

3. 方法catch表是如何存储方法的

• 我们都是知道调用方法的时候，会根据对象的isa查找到对象类对象，并开始在catch表里面查询对应的IMP

• 其实catch是个散列表,是根据方法的@selector(方法名) & catch->mask(catck表最大数量 - 1)得到index，如果index已经存储了新的方法，那么就会index++，如果index对应的值为nil时，将响应的方法，插入到catch表里面

• 核心代码

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver) {
// 获取类对象的catch地址
  cache_t *cache = &cls->cache
// 获取key
  cache_key_t key = (cache_key_t)sel;
// 找到bucket
  bucket_t *bucket = cache->find(key, receiver);
}

bucket_t * cache_t::find(cache_key_t k, id receiver)
{
// catch表的buckets属性
    bucket_t *b = buckets();
// catch 表示的mask 最大值 - 1
    mask_t m = mask();

    mask_t begin = cache_hash(k, m);
    mask_t i = begin;
do {
if (b[i].key() == 0  ||  b[i].key() == k) {
return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);
}
static inline mask_t cache_next(mask_t i, mask_t mask) {
return (i+1) & mask;
}

注意：catch表的扩容，同样也是和weak_table一样按照2倍的方式进行扩容，但是注意：扩容后，以前缓存的方法则会被删除掉。

简易代码

void cache_t::expand() {
uint32_t oldCapacity = capacity();
uint32_t newCapacity = oldCapacity ? oldCapacity*2 : INIT_CACHE_SIZE;
    reallocate(oldCapacity, newCapacity);
}

void cache_t::reallocate(mask_t oldCapacity, mask_t newCapacity)
{
// 获取旧的oldBuckets
    bucket_t *oldBuckets = buckets();
    // 重新分配新的
    bucket_t *newBuckets = allocateBuckets(newCapacity);
    // free 掉旧的
    cache_collect_free(oldBuckets, oldCapacity);
}

4. 优化后isa指针是什么样的？存储都有哪些内容？

• 最新的Objective-C的对象里面的isa指针已经不是单单的指向所属类的地址了的指针了，而时变成了一个共用体,并且使用位域来存储更多的信息

5. App启动流程，以及如何优化？

• 启动顺序

     1. dyld，Apple的动态连接器，可以用来装载Mach-O文件(可执行文件、动态库)

       1.1、装载App的可执行文件，同事递归加载所有依赖的动态库

       1.2 、当dyld把可执行文件、动态库装载完毕后，会通知Runtime进行下一步的处理

• Runtime

     1. 调用map_images进行可执行文件内容的解析和处理

     2. 在load_images里面调用call_load_methods,调用所有class和category的+load方法

     3. 进行各种objc结构的初始化(注册Objc类，初始化类对象等等)

     4. 到目前未知，可执行文件和动态库中所有的符号(Class,Protocol,Selector,IMP..)都已经按照格式成功加载到内存中，被runtime管理

• main函数调用

     1. 所有初始化工作结束后，dyld就会调用main函数

     2. 截下来就是UIApplicationMan函数，AppDelegate的application:didFinishLaunchingWithOptions:的

• App启动速度优化
  

      1. dyld

       1.1、减少动态库，合并一些自定义的动态库，以及定期清理一些不需要的动态库

       1.2、较少Objc类、category的数量、以及定期清理一些不必要的类和分类

       1.3、Swift尽量使用struct

     2. Runtime

       2.1、使用+initialize和dispatch_once取代Objc的+load方法、C++的静态构造器

     3. main

       3.1、再不印象用户体验的情况下面，尽可能的将一些操作延迟，不要全部放到finishLaunching

       3.2、一些网络请求

       3.3、一些第三方的注册

       3.4、以及window的rootViewController 的viewDidload方法，也别做耗时操作

     4. 注意：我们可以添加环境变量可以打印出App的启动时间分析(Edit scheme -> Run -> Arguments)

       4.1、DYLD_PRINT_STATISTICS设置为1，可以打印出来每个阶段的时间

       4.2、如果需要更详细的信息，那就设置DYLD_PRINT_STATISTICS_DETAILS为1

6. App瘦身

• 资源(图片、音频、视频等)

    1. 可以采取无损压缩

     2. 使用LSUnusedResources去除没有用的资源 LSUnusedResources

• 可执行文件瘦身

     1. Strip Linked Product、Make Strings Read-Only、Symbols Hidden by Default设置为true

     2. 去掉一些异常支持 Enable C++ Exceptions、Enable Objective-C Exceptions设置为false

     3. 使用AppCode检测未使用的代码：菜单栏 -> Code -> Inspect Code，等编译完成后，会看到未使用的类

• 生成LinkMap文件，可以查看可执行文件的具体组成

     1. 可借助第三方工具解析LinkMap文件LinkMap

     Link Map解析结果