发送消息

在runtime学习一里边，介绍了Objective-C是动态语言，尽可能把决策推迟到运行时。runtime是由C、C++及汇编写成的一套API为Objective-C提供运行时功能。当源码编译完成，runtime将Objective-C转成C语言，今天主要研究下OC底层方法调用机制。

TestMessage *test = [[TestMessage alloc]init];
[test message];

举一个简单的列子说明，自定义一个TestMessage类，实例化一个对象test,然后使用test实例调用TestMessage类的一个实例方法。给[test message]这段代码打上断点，运行代码查看汇编。

图一

图二

由上述函数的字面意思也能大概意识到，我们使用OC的实例对象调用方法到底层是使用objc_msgSend这个函数，给我们的是实例对象发送一个@selector(message)的一个消息。

在OC的方法中隐藏了两个参数，第一个就是id 类型的self和SEL 类型的_cmd

概念总结

isa及父类的走位流程图.

图三

这张图一定要印在脑海里，因为它真的很重要。在底层查找方法的流程，利用这张图我们能够更好更清晰的理解其中的机制。

struct objc_class : objc_object {
    // Class ISA;
    Class superclass;
    cache_t cache;             // formerly cache pointer and vtable
    class_data_bits_t bits;    // class_rw_t * plus custom rr/alloc flags

    class_rw_t *data() { 
        return bits.data();
    }
    void setData(class_rw_t *newData) {
        bits.setData(newData);
    }

    void setInfo(uint32_t set) {
        assert(isFuture()  ||  isRealized());
        data()->setFlags(set);
    }

struct class_rw_t {
    // Be warned that Symbolication knows the layout of this structure.
    uint32_t flags;
    uint32_t version;

    const class_ro_t *ro;

    method_array_t methods;
    property_array_t properties;
    protocol_array_t protocols;

    Class firstSubclass;
    Class nextSiblingClass;

    char *demangledName;

#if SUPPORT_INDEXED_ISA
    uint32_t index;
#endif

    void setFlags(uint32_t set) 
    {
        OSAtomicOr32Barrier(set, &flags);
    }

    void clearFlags(uint32_t clear) 
    {
        OSAtomicXor32Barrier(clear, &flags);
    }

    // set and clear must not overlap
    void changeFlags(uint32_t set, uint32_t clear) 
    {
        assert((set & clear) == 0);

        uint32_t oldf, newf;
        do {
            oldf = flags;
            newf = (oldf | set) & ~clear;
        } while (!OSAtomicCompareAndSwap32Barrier(oldf, newf, (volatile int32_t *)&flags));
    }
};

从类的底层结构、上图的走位图，再加上对元类的理解，简单总结几点：

1. isa指针，万事万物皆对象，每个对象都有isa指针，isa指向对象所属的类。实例对象的isa指向类对象，类对象的isa指向元类，元类的isa指向根元类。
2. 子类的superclass指向父类,父类superclass指向根类，根类的superclass指向nil。子元类的superclass指向父元类，父元类的superclass指向根元类，根元类的superclass又指向了根类。
3. 实例对象的方法存储在类对象里边，类对象的方法(也就是通常我们所说的类方法)存储在元类里边，类对象及元类对象里边的方法都是实例方法。

当实例变量调用实例方法时，编译器将OC代码翻译成C语言，然后使用runtime系统给这个实例变量发送这个方法编号的消息。runtime发送消息本质上就是使用运行时动态的查找函数具体实现的IMP指针。
由于runtime是由汇编、C及C++编写的API，所以在动态查找方法实现时，用到了汇编，C及C++.

1. 当查找类的缓存时，以及最后的消息转发用的都是汇编。
2. 当缓存中没有找到时，使用C及C++查找当前类及递归查找父类的方法列表，还有就是当找到NSObject类都没有找到时，来到第一次方法动态决议时，都是C和C++。

源码分析

为了研究苹果底层发送消息的流程，我们需要在下载苹果的objc4-750源码，或者在github上下载可编译的源码。

图三

在源码里边添加测试代码如上，然后打上断点，运行代码，进入到汇编

图四

1.查找缓存

图五

图六

图七

1. CacheHit:一个宏定义，字面理解就是命中或者找到，注释的意思就是调用或者返回imp指针。
2. CheckMiss:宏定义,字面理解就是没有找到。
3. add:这个方法就是进行缓存。

图八

图九

图十

由此我们先总结一下快速的缓存查找:

1. 缓存的查找源代码是用汇编写成的。
2. 缓存的查找结果：
   • CacheHit即在缓存中找到了对应的IMP指针。
   • CheckMiss即在缓存中没有找到对应的IMP指针，将进入到慢速的方法列表查找方式。
   • 缓存中没有找到IMP,但是在其他的途径找到IMP则将方法编号和IMP指针进行缓存。

2.方法列表查找

由缓存的查找流程得到，当CheckMiss之后，就会跳转至MethodTableLookup宏。

图十一

图十二

图十三

图十四

图十五

if (cache) {
        imp = cache_getImp(cls, sel);
        if (imp) return imp;
    }

此判断是不会走的，因为在调用方法的时候cache变量是个NO.也可以理解，因为如果有缓存就不会来到这个lookUpImpOrForward函数里边。

 if (initialize  &&  !cls->isInitialized()) {
        runtimeLock.unlock();
        _class_initialize (_class_getNonMetaClass(cls, inst));
        runtimeLock.lock();
    }

这块是给类对象发送initialize方法,暂时先不看，因为和查找方法的流程没什么关系。

retry:    
    runtimeLock.assertLocked();

    // Try this class's cache.

    imp = cache_getImp(cls, sel);
    if (imp) goto done;

    // Try this class's method lists.
    {
        Method meth = getMethodNoSuper_nolock(cls, sel);
        if (meth) {
            log_and_fill_cache(cls, meth->imp, sel, inst, cls);
            imp = meth->imp;
            goto done;
        }
    }

static method_t *
getMethodNoSuper_nolock(Class cls, SEL sel)
{
    runtimeLock.assertLocked();

    assert(cls->isRealized());
    // fixme nil cls? 
    // fixme nil sel?

    for (auto mlists = cls->data()->methods.beginLists(), 
              end = cls->data()->methods.endLists(); 
         mlists != end;
         ++mlists)
    {
        method_t *m = search_method_list(*mlists, sel);
        if (m) return m;
    }

    return nil;
}

retry开始就进入了重要的查找流程了.

1. 判断cache里边是否有，因为多线程等原因有可能此时缓存列表中已经有了对应的IMP如果有会跳转至done，
2. 进入当前类的方法列表里边查找，如果能够找到meth这个方法，则会log_and_fill_cache(cls, meth->imp, sel, inst, cls);缓存这个方法然后跳转至done。
3. 当前类里边没有找到的话，就会继续走下边的流程。

// Try superclass caches and method lists.
    {
        unsigned attempts = unreasonableClassCount();
        for (Class curClass = cls->superclass;
             curClass != nil;
             curClass = curClass->superclass)
        {
            // Halt if there is a cycle in the superclass chain.
            if (--attempts == 0) {
                _objc_fatal("Memory corruption in class list.");
            }
            
            // Superclass cache.
            imp = cache_getImp(curClass, sel);
            if (imp) {
                if (imp != (IMP)_objc_msgForward_impcache) {
                    // Found the method in a superclass. Cache it in this class.
                    log_and_fill_cache(cls, imp, sel, inst, curClass);
                    goto done;
                }
                else {
                    // Found a forward:: entry in a superclass.
                    // Stop searching, but don't cache yet; call method 
                    // resolver for this class first.
                    break;
                }
            }
            
            // Superclass method list.
            Method meth = getMethodNoSuper_nolock(curClass, sel);
            if (meth) {
                log_and_fill_cache(cls, meth->imp, sel, inst, curClass);
                imp = meth->imp;
                goto done;
            }
        }
    }

递归的在父类里边查找:

1. 递归的由当前类获取到父类直至NSObject类。
2. 在父类的缓存中查找，由代码可知，此过程走的是汇编.(这里省略),如果拿到IMP，且IMP不是消息转发的缓存，则将IMP进行缓存。
3. 如果在父类的缓存中没有找到，则进入到父类的方法列表中进行查找。找到则缓存起来。

慢速的查找流程总结：

1. 由于多线程原因还是会使用汇编去查找当前类的缓存，找到则返回IMP。
2. 当前类缓存中没有，则会进入该类的方法列表中查找，如果找到则缓存然后返回IMP.
3. 在当前类的方法列表中没有找到，则会的获取父类，使用汇编查找父类的缓存，如果找到且不是消息转发的缓存，便会缓存然后返回IMP，如果没有找到又会进入到父类的方法列表继续进行2和3的操作直到NSObject类的方法列表中也没有找，就会进入到消息动态决议流程。

消息的查找流程有快速的查找缓存流程和慢速的查找方法列表流程

消息动态解析及转发流程

当消息经过缓存及方法列表这两种方式都没有找到IMP的话，就会进入消息的动态解析及转发。

1.消息转发流程图

图十六

看流程图可以清楚的知道消息转发处理流程。

2.消息转发代码分析

当消息查找流程结束就到了消息的动态决议流程：

图十七

图十八

图十九

1. 消息的动态决议只会执行一次，从triedResolver这个变量可以看出，进入之后会被赋为YES.
2. _class_resolveMethod函数里边，将类和元类分开处理。
3. 从当前类开始一直找到NSObject类，是否重写了SEL_resolveInstanceMethod(+resolveInstanceMethod)这个方法。
4. 如果有重写，就会给这个类发送resolveInstanceMethod消息。
   
   图二十
   
   在resolveInstanceMethod方法里使用使用runtime的API给这个类添加实例方法。类方法的原理一样。在这个方法里边处理完成就不会到消息转发流程，未处理里便会来到消息转发。
   
   图二十一
   
   由_objc_msgForward_impcache这个函数便会进入到汇编。
   
   图二十二
   
   进入到汇编代码，此处不再看汇编的具体实现，只看下回调方法的使用.
   
   图二十三
   
   动态决议是给类添加方法，来解决问题。
   
   图二十四
   
   把消息转发给能响应方法的对象
   
   图二十五
   
   将方法签名，再转发。