iOS面试题（三）

1. ARC帮我们做了什么？

• 使用LLVM + Runtime 结合帮我管理对象的生命周期

• LLVM 帮我们在代码合适的地方添加release、retarn、autorelease等添加计数器或者减少计数器操作

• Runtime 帮我们像__weak、copy等关键字的操作

2.initialize和load是如何调用的？它们会多次调用吗？

• load方法说在应用加载的时候，Runtime直接拿到load的IMP直接去调用的，而不是像其他方式根据objc_msgSend(消息机制)来调用方法的

• load方法调用的顺序是根据类的加载的前后进行调用的，但是每个类调用的顺序是superclass->class->category顺序调用的，每个load方法只会调用一次(手动调用不算)

• 一下为Runtime源码的主要代码：

load_images(const char *path __unused, const struct mach_header *mh) {
// 准备class 和category
  prepare_load_methods((const headerType *)mh);
  // 调用load方法
  call_load_methods();
}

void prepare_load_methods(const headerType *mhdr) {
  classref_t *classlist = 
      _getObjc2NonlazyClassList(mhdr, &count);
  for (i = 0; i < count; i++) {
      schedule_class_load(remapClass(classlist[i]));
  }
  category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
  for (i = 0; i < count; i++) {
      category_t *cat = categorylist[i];
      add_category_to_loadable_list(cat);
  }
}

static void schedule_class_load(Class cls) {
  // 开始递归，加载superclass
  schedule_class_load(cls->superclass);
  add_class_to_loadable_list(cls);
}

void call_load_methods(void) {
  do {
      while (loadable_classes_used > 0) {
          call_class_loads();
      }
      more_categories = call_category_loads();
  } while (loadable_classes_used > 0  ||  more_categories);
}

static void call_class_loads(void) {
  // 在此add_class_to_loadable_list 里面准备了所有重写load的方法的类
  struct loadable_class *classes = loadable_classes;
  // Call all +loads for the detached list.
  for ( int i = 0; i < used; i++) {
      Class cls = classes[i].cls;
      // 获取到load 方法的imp
      load_method_t load_method = (load_method_t)classes[i].method;
      // 调用laod 方法
      (*load_method)(cls, SEL_load);
  }
}

static bool call_category_loads(void) {
  // 在prepare_load_methods 方法里面准备了所有重新load方法的category
  struct loadable_category *cats = loadable_categories;
  for (int i = 0; i < used; i++) {
      // 获取到catgegory
      Category cat = cats[i].cat;
      // 获取category 的load 方法的IMP实现
      load_method_t load_method = (load_method_t)cats[i].method;
      cls = _category_getClass(cat);
      if (cls  &&  cls->isLoadable()) {
          // 调用load方法
          (*load_method)(cls, SEL_load);
      }
  }
}

• initialize方法的调用其实和其他方法调用一样的，objc_msgSend(消息机制)来调用的。调用的数序是：没有初始话的superclass -> 实现initialize的categort 或者 实现了initialize的class，如果class没有实现initialize 方法，则会调用superclass的initialize,因为initialize的底层是使用了objc_msgSend

• 看下Runtime底层调用_class_initialize的源码

void _class_initialize(Class cls) {
    supercls = cls->superclass;
if (supercls  &&  !supercls->isInitialized()) {
// 又是个递归
        _class_initialize(supercls);
    }
    // 调用 initialize方法
    callInitialize(cls);
  }
  // objc_msgSend 调用 initialize 方法
  void callInitialize(Class cls) {
    // **注意：因为使用了objc_msgSend,有可能调用class的 initialize **
    objc_msgSend(cls, SEL_initialize);
  }

总结:
load方法一个类只会调用一次(除去手动调用)，而调用的数序是，从superclass -> class -> category,category里面的顺序是先编译，先调用
initialize方法，一个类可能会调用多次，如果子类没有实现initialize方法，当第一次使用此类的时候，会调用superclass。而调用的顺序是，superclass -> 实现initialize的category 或者 实现了initialize方法(没有category实现initialize) 或者 superclass的initialize (没有子类和category实现initialize方法)

3.说下autoreleasepool

• 在MRC下，当对象调用autorerelease方法时候，会将对象加入到对象前面的哪一个autoreleasepool里面,并且当autoreleasepool作用域释放的时候，会对里面的所有的对象进行一次release操作。

• autoreleasepool底层是使用了AutoreleasePoolPage对象来管理的，AutoreleasePoolPage是一个双向的链表,每个AutoreleasePoolPage都有4096个字节，除了用来存放内部的成员变量，剩下的控件都会用来存放autorelease对象的地址

/// AutoreleasePoolPage 的简化的结构
class AutoreleasePoolPage {
  magic_t const magic;
  // 下一次可以存储对象的地址
  id *next;
  pthread_t const thread;
  // 标识上一个page对象
  AutoreleasePoolPage * const parent;
  // 标识下一个page对昂
  AutoreleasePoolPage *child;
  uint32_t const depth;
  uint32_t hiwat;
}

• 当autoreleasepool开始的时候，会调用AutorelasePoolPage的push方法，会讲一个标识POOL_BOUNDARY添加到AutoreleasePoolPage对象里面，并且返回POOL_BOUNDARY的地址r1(暂且这样叫)

• 当对像进行relase的时候，会将对象的地址添加到当前AutorelasePoolPage里面，依次添加。

• 当autoreleasepool作用域结束的时候，会调用AutorelasePoolPage的pop(r1)方法(r1为当前aotoreleasepool开始的加入标识POOL_BOUNDARY的地址)，AutorelasePoolPage则会将里面保存的对象的从左后一个开始进行release操作，当碰到r1时候，标识当前那个autoreleasepool里面所有的对象都进行了一次release操作。

@autoreleasepool {
// 此处会调用
   void *ctxt = AutoreleasePoolPage::push();
// 添加到最近的一个autoreleasepool中
  [[[NSObject alloc]init] autorelease];
//移除作用域的时候调用
  AutoreleasePoolPage:pop(ctxt)
}
// autoreleasepool 作用域开始会调用AutoreleasePoolPage::push()
static inline void *push() {
  id *dest;
if (DebugPoolAllocation) {
// 创建一个心的page对象
    dest = autoreleaseNewPage(POOL_BOUNDARY);
  } else {
// 已经有了page对象，讲`pool_boundary`添加进去
    dest = autoreleaseFast(POOL_BOUNDARY);
  }
}
static inline id *autoreleaseFast(id obj)
{
// 获取正在使用的page对昂
  AutoreleasePoolPage *page = hotPage();
// page还没有装满
if (page && !page->full()) {
return page->add(obj);
  } else if (page) {
// 已经添加满了
return autoreleaseFullPage(obj, page);
  } else {
// 没有page对象，创建心的page对象
return autoreleaseNoPage(obj);
  }
}
// 对象调用release 的简介源码
id objc_object::rootAutorelease2() {
return AutoreleasePoolPage::autorelease((id)this);
}
static inline id autorelease(id obj) {
// 同样也是添加进去
  id *dest = autoreleaseFast(obj);
return obj;
}
// page调用pop简介源码 *token 表示结束的标识
static inline void pop(void *token) {
  AutoreleasePoolPage *page;
  id *stop;
  page = pageForPointer(token);
  stop = (id *)token;
  page->releaseUntil(stop);
}
// 释放对象的源码
void releaseUntil(id *stop) {
// next 标识当前page可以存储对象的下一个地址
while (this->next != stop) {
    AutoreleasePoolPage *page = hotPage();
// 因为page是个双向链表，当page为空的时候，需要往上查找parent的page对象里面存储的睇相
while (page->empty()) {
      page = page->parent;
      setHotPage(page);
    }
    id obj = *--page->next;
if (obj != POOL_BOUNDARY) {// obj 不是刚开始传入的POOL_BOUNDARY及表示对象，所以需要调用一次操作
      objc_release(obj);
    }
  }
}

autoreleasepool和runloop的关系

• runloop里面会注册两个Observer来监听runloop的状态变化

• 其中一个Observer监听的状态为kCFRunLoopEntry进入runloop的状态，则会调用AutoreleasePoolPage::push()方法

• 另外中一个Observer监听的状态为kCFRunLoopBeforeWaiting、kCFRunLoopExit,即将休眠和退出当前的runloop。

• 在kCFRunLoopBeforeWaiting的回掉里面会调用AutoreleasePoolPage::pop(ctxt)和AutoreleasePoolPage::(push)方法，释放上一个autoreleasepool里面添加的对象，并开启下一个autoreleasepool。

• 在kCFRunLoopExit的Observer回掉里面会调用AutoreleasePoolPage::(push)释放autoreleasepool里面的对象

4.category属性是存储在那里？

• 我们都知道可以使用Runtime的objc_setAssociatedObject、objc_getAssociatedObject两个方法给category的属性重写get、set方法，而此属性的值是存储在那里呢？

• 其实此属性的值保存在一个AssociationsManager里面。

• 我们也是可以根据源码看一下

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
// 一下为精简的代码
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
          ObjectAssociationMap *refs = new ObjectAssociationMap;
          associations[disguised_object] = refs;
          (*refs)[key] = ObjcAssociation(policy, new_value);
        }
    }
}

5.category方法是如何添加的？

• 当我们给分类添加相同的方法的时候，会调用category里面的方法，而不是调用我们class里面的方法

• 当编译器编译的时候，编译器会将category编译成category_t这样的结构体，等类初始化的时候，会将分类的信息同步到class_rw_t里面,包含：method、property、protocol等，同步的时候会将category里面的信息添加到class的前面(而不是替换掉class里面的方法)，而方法调用的时候，而是遍历class_rw_t里面的方法，所以找到分类里面的IMP则返回。 

• 使用memmove,将类方法移动到后面
• 使用memcpy,将分类的方法copy到前面
• 当多个分类有相同的方法的时候，调用的顺序是后编译先调用
• 当类初始化同步category的时候，会使用while(i--)的倒序循环，将后编译的category添加到最前面。