一 runtime简介

二 Class的结构

三 isa指针详解

四 method详解

五 方法调用及消息转发流程

六 runtime常用api

七 runtime开发中具体应用

一 runtime简介

定义：所谓运行时, 就是尽可能地把决定从编译器推迟到运行期, 就是尽可能地做到动态. 只是在运行的时候才会去确定对象的类型和方法的. 因此利用Runtime机制可以在程序运行时动态地修改类和对象中的所有属性和方法.
Objective-C中调用对象的方法时, 会向该对象发送一条消息, runtime根据该消息做出反应.
Runtime是一套比较底层的纯C语言的API, Objective-C是运行在Runtime上的, 因此在Runtime中动态添加和实现一些非常强大的功能也就不足为奇了.
在Objective-C代码中使用Runtime, 需要引入<#import <objc/runtime.h>

总结说明：

runtime是什么?

runtime是一组APi，我们平时开发也用到很多API，所以runtime并没啥稀奇的，只不过使用c语言写的，GCD也是C语言写的API库。

runtime API干啥用的?

程序运行时动态地修改类和对象中的所有属性和方法，就是用来在程序运行是改变类的属性和行为的，就像GCD就是用来操作线程的。

二 Class的结构

既然是一组API来操作类的，首先我们就先来了解下类的本质是什么，然后再看它是怎么操作它的。

2.1我们看下类的本质定义

objc 源码地址 objc-runtime-new.h

class 结构图

我们看出来，它实际上就是用一个结构体来定义的，我们想想一个类它有什么，它首先有，属性，方法，然后有父类，他自己的标示等等。这个结构体里面基本都包含了。
接下来让我们具体解释一下这个结构体里面的每一项内容

2.1.1 ISA

Class ISA;  

objc_class 中也有一个 isa 指针，这说明 Objc 类本身也是一个对象。为了处理类和对象的关系，Runtime 库创建了一种叫做 Meta Class(元类) 的东西，类对象所属的类就叫做元类。Meta Class 表述了类对象本身所具备的元数据。

我们所熟悉的类方法，就源自于 Meta Class。我们可以理解为类方法就是类对象的实例方法。每个类仅有一个类对象，而每个类对象仅有一个与之相关的元类。

当你发出一个类似 NSObject alloc 的消息时，实际上，这个消息被发送给了一个类对象(Class Object)，这个类对象必须是一个元类的实例，而这个元类同时也是一个根元类(Root Meta Class)的实例。所有元类的 isa 指针最终都指向根元类。 下一节我们再详细介绍。

2.1.2 cache_t

struct cache_t {
    struct bucket_t *_buckets;
    mask_t _mask;
    mask_t _occupied;

Cache 为方法调用的性能进行优化，每当实例对象接收到一个消息时，它不会直接在 isa 指针指向的类的方法列表中遍历查找能够响应的方法，因为每次都要查找效率太低了，而是优先在 Cache 中查找。
Runtime 系统会把被调用的方法存到 Cache 中，如果一个方法被调用，那么它有可能今后还会被调用，下次查找的时候就会效率更高。就像计算机组成原理中 CPU 绕过主存先访问 Cache 一样。
这个cache主要是方法调用的优化，别的没啥。

2.1.3 class_rw_t

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;
}

class_rw_t里面的methods、properties、protocols是二维数组，是可读可写的，包含了类的初始内容、分类的内容,二位数组存储是为的更好的扩展新加的方法属性或协议。类和分类的信息都存储在这个结构体里面

2.1.3 class_ro_t

struct class_ro_t {
    uint32_t flags;
    uint32_t instanceStart;
    uint32_t instanceSize; //实例对象占用内存空间大小
#ifdef __LP64__
    uint32_t reserved;
#endif
    const uint8_t * ivarLayout;
    const char * name; //类名
    method_list_t * baseMethodList;
    protocol_list_t * baseProtocols;
    const ivar_list_t * ivars; //成员变量列表

    const uint8_t * weakIvarLayout;
    property_list_t *baseProperties;
}

class_ro_t里面的baseMethodList、baseProtocols、ivars、baseProperties是一维数组，是只读的，类的成员变量是存放在这里。
类的基本结构大致就这些，接下来我们要详细了解一下ISA指针，很多方面的东西都牵扯到它。

三 isa指针详解

3.1

在arm64架构之前，isa就是一个普通的指针，存储着Class、Meta-Class对象的内存地址
从arm64架构开始，对isa进行了优化，变成了一个共用体（union）结构，还使用位域来存储更多的信息
objc-private.h

union isa_t {
    isa_t() { }
    isa_t(uintptr_t value) : bits(value) { }

    Class cls;
    uintptr_t bits;
#if defined(ISA_BITFIELD)
    struct {
        ISA_BITFIELD;  // defined in isa.h
    };
#endif
};

isa.h

# if __arm64__
#   define ISA_MASK        0x0000000ffffffff8ULL
#   define ISA_MAGIC_MASK  0x000003f000000001ULL
#   define ISA_MAGIC_VALUE 0x000001a000000001ULL
#   define ISA_BITFIELD                                                      \
      uintptr_t nonpointer        : 1;                                       \
      uintptr_t has_assoc         : 1;                                       \
      uintptr_t has_cxx_dtor      : 1;                                       \
      uintptr_t shiftcls          : 33; /*MACH_VM_MAX_ADDRESS 0x1000000000*/ \
      uintptr_t magic             : 6;                                       \
      uintptr_t weakly_referenced : 1;                                       \
      uintptr_t deallocating      : 1;                                       \
      uintptr_t has_sidetable_rc  : 1;                                       \
      uintptr_t extra_rc          : 19
#   define RC_ONE   (1ULL<<45)
#   define RC_HALF  (1ULL<<18)

ISA_BITFIELD ISA位域信息解释
nonpointer
0，代表普通的指针，存储着Class、Meta-Class对象的内存地址
1，代表优化过，使用位域存储更多的信息
has_assoc
是否有设置过关联对象，如果没有，释放时会更快
has_cxx_dtor
是否有C++的析构函数（.cxx_destruct），如果没有，释放时会更快
shiftcls
存储着Class、Meta-Class对象的内存地址信息
magic
用于在调试时分辨对象是否未完成初始化
weakly_referenced
是否有被弱引用指向过，如果没有，释放时会更快
deallocating
对象是否正在释放
extra_rc
里面存储的值是引用计数器减1
has_sidetable_rc
引用计数器是否过大无法存储在isa中
如果为1，那么引用计数会存储在一个叫SideTable的类的属性中
我们可以看到arm64架构之后isa 不仅存储着Class、Meta-Class对象的内存地址还存储着其他更多信息， Class、Meta-Class对象的内存地址被存储在shiftcls 中占用33位
uintptr_t shiftcls : 33
所以我们从一个对象isa指针看到的并不是对象真实的内存地址，我们要做一下位运算才能得到真实的地址要 & MASK.
既然isa存储这几种对象的内存地址，那我们就来了解下oc的几种对象。

3.2 Objective-C中的对象

Objective-C中的对象，简称OC对象，主要可以分为3种
instance对象（实例对象）
class对象（类对象）
meta-class对象（元类对象）

3.2.1 实例对象 instance

instance对象就是通过类alloc出来的对象，每次调用alloc都会产生新的instance对象

    Person *person1 = [[Person alloc] init];
    Person *person2 = [[Person alloc] init];
    Person *person3 = [[Person alloc] init];
    Person *person4 = [[Person alloc] init];

person1、person2,person3,person4是Person类的instance对象（实例对象）
它们是不同的四个对象，分别占据着四块不同的内存

(lldb) po person1
<Person: 0x102805b70>
(lldb) po person2
<Person: 0x102805bc0>
(lldb) po person3
<Person: 0x102805bd0>
(lldb) po person4
<Person: 0x102805be0>

instance对象在内存中存储的信息包括
isa指针,及它自己的成员变量

3.2.2 class对象（类对象）

  Person *person1 = [[Person alloc] init];
Person *person2 = [[Person alloc] init];
//传入对象的类对象
Class p1class = [person1 class];
Class p2class = [person2 class];
NSLog(@"p1class:%p\n p2class:%p",p1class,p2class);

22:17:12.098954+0800 test[4172:228782]
p1class:0x100002180
p2class:0x100002180

p1class ,p2class都是Person的class对象（类对象）
它们是同一个对象。每个类在内存中有且只有一个class对象
class对象在内存中存储的信息主要包括
isa指针
superclass指针
类的属性信息（@property）、类的对象方法信息（instance method）//存的是动态方法，为空
类的协议信息（protocol）、类的成员变量信息（ivar） //存储的是空值
......

3.2.3 meta-class对象（元类对象)

  Person *person1 = [[Person alloc] init];
    Person *person2 = [[Person alloc] init];
    //传入对象的类对象获取元类对象
    Class p1metaclass = object_getClass([person1 class]);
    Class p2metaclass = object_getClass([person2 class]);
    Boolean ismetaclass = class_isMetaClass(p1metaclass);//判断是否是元类对象
    NSLog(@"p1class:%p\n p2class:%p",p1metaclass,p2metaclass);

22:10:13.933354+0800 test[4129:225264] p1class:0x1000021a8
 p2class:0x1000021a8

p1metaclass是Person的meta-class对象（元类对象）
每个类在内存中有且只有一个meta-class对象
meta-class对象和class对象的内存结构是一样的，但是用途不一样，在内存中存储的信息主要包括
isa指针
superclass指针
类的类方法信息（class method）存的是静态方法
......

3.3 isa的与三种对象之间的关系

• 实例对象（instance）的isa指向类对象（class）
• 类对象（class）的isa指向元类对象meta-class）

他们的关系图如下所示：

isa与三种对象的关系图

当调用对象方法时，通过instance的isa找到class，最后找到对象方法的实现进行调用
当调用类方法时，通过class的isa找到meta-class，最后找到类方法的实现进行调用

3.4 supperclass讲解

supperclass只存在于类对象与元类对象里，它的作用想必大家也能猜到，遇到继承关系的时候supperclass就派上用场了，下面我们就分别讲解一下，类对象里的supperclass以及元类对象里的supperclass

3.4.1 类对象里的supperclass

@interface Student : Person

@interface Person: NSObject

我们定义了两个对象的继承关系Student继承Person，Person继承NSObject，那么他们的类对象关系图如下：

类对象里的supperclass关系图

当Student的instance对象要调用Person的对象方法时，会先通过isa找到Student的class，然后通过superclass找到Person的class，最后找到对象方法的实现进行调用

3.4.2 元类对象里的supperclass

@interface Student : Person

@interface Person: NSObject

我们定义了两个对象的继承关系Student继承Person，Person继承
NSObject，那么他们的类对象关系图如下：

元类对象里的supperclass关系图

当Student的class要调用Person的类方法时，会先通过isa找到Student的meta-class，然后通过superclass找到Person的meta-class，最后找到类方法的实现进行调用

3.5 isa、superclass总结

isa supperclass关系图总结

1 instance的isa指向class
2 class的isa指向meta-class
3 meta-class的isa指向基类的meta-class
4 class的superclass指向父类的class
如果没有父类，superclass指针为nil

5 meta-class的superclass指向父类的meta-class
基类的meta-class的superclass指向基类的class
6 instance调用对象方法的轨迹
isa找到class，方法不存在，就通过superclass找父类
7 class调用类方法的轨迹
isa找meta-class，方法不存在，就通过superclass找父类
这个图已经很经典了需要大家细细品味。

四 method详解

4.1.1 method_t

上面我们讲过的类的结构中，我们可以看到，一个类的一些方法，协议，属性等是存在class_rw_t这个结构体中的。

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;
}

平时用的最多的就是方法调用了，下面让我们来深入了解一下method_array_t methods; // 方法列表
先看一下method_array_t是什么
objc-runtime-new.h

class method_array_t : 
    public list_array_tt<method_t, method_list_t> 
{
    typedef list_array_tt<method_t, method_list_t> Super;

 public:
    method_list_t **beginCategoryMethodLists() {
        return beginLists();
    }
    
    method_list_t **endCategoryMethodLists(Class cls);

    method_array_t duplicate() {
        return Super::duplicate<method_array_t>();
    }
};

我们可以看出这个类结构大概是下面这种结构的

method类结构

class_rw_t里面的methods是二维数组，是可读可写的，包含了类的初始内容、分类的内容,那么mathod_t内部结构是什么样的，我们来看一下

struct method_t {
    SEL name;   // 函数名
    const char *types; //编码（返回值，参数）
    MethodListIMP imp;  //函数地址

    struct SortBySELAddress :
        public std::binary_function<const method_t&,
                                    const method_t&, bool>
    {
        bool operator() (const method_t& lhs,
                         const method_t& rhs)
        { return lhs.name < rhs.name; }
    };
};

由此结构我们可以看出method_t就是对一个函数的具体描述，包含函数的名称，函数的出参，入参，以及函数具体地址，那么我们就具体来说一下它这几个变量

MethodListIMP

// Method lists use process-independent signature for compatibility.
using MethodListIMP = IMP __ptrauth_objc_method_list_imp;

#else

using MethodListIMP = IMP;

#endif

objc.h

#if !OBJC_OLD_DISPATCH_PROTOTYPES
typedef void (*IMP)(void /* id, SEL, ... */ ); 
#else
typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...); 
#endif

IMP 代表函数的具体实现

SEL

objc.h

typedef struct objc_selector *SEL;

1 SEL代表方法\函数名，一般叫做选择器，底层结构跟char *类似
2 可以通过@selector()和sel_registerName()获得
可以通过sel_getName()和NSStringFromSelector()转成字符串

 SEL speaksel = sel_registerName(@"speak");
 SEL speaksel2 = @selector(speak);

3 不同类中相同名字的方法，所对应的方法选择器是相同的

这个其实很好理解，同一个类的不同对象，它的类结构都是一样的，类结构存储一份就好了，所以它们方法描述也只有一份，所有这个类的对象共用一份方法描述，只是每个对象传的出参，入参，不一样罢了。

types

const char *types 

描述方法参数类型的字符数组,types包含了函数返回值、参数编码的字符串

描述方法参数类型的字符数组的第一个字符是代表返回值的类型，后面的字符依次代表参数的类型，因为Objective-C中的函数会包含两个隐式参数，也就是方法调用者和方法名，例如

+（void）method

实际应该是

void method(id self, SEL _cmd)

如果返回值为空，那么函数的类型编码的第一个字符是v,如果不为空，则为返回值类型对应的编码，详细的可以看下面的编码对应表
因为第一个参数是方法调用者，它的类型肯定是对象类型，所以类型编码的第二个字符一定是@

因为第二个参数是方法名的类型，第三个字符一定是 ：

所以这个函数

void method(id self, SEL _cmd)        

的类型编码为 "v@:"

那么如果要添加的函数是一个set函数，类型编码是怎么样的呢？

-（void）setA:(NSString *)a

同理，set方法实际的函数是这样的：

void setA(id self, SEL _cmd, id a)  

与上面无参数的方法相比,只是多了一个参数，

所以类型编码为"v@:@",代码为

class_addMethod(self, @selector(setA:), (IMP)setA,"v@:@");

iOS中提供了一个叫做@encode的指令，可以将具体的类型表示成字符串编码

encoding type

encoding type

由此方法描述的几个字段我们就讲解完了，接下来我们来讲解一下方法缓存

4.2方法缓存

在本文第一个图例，类结构中有一个cache字段

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
}
   

cache_t cache 就是用来缓存方法的，下面我们来看一下cache_t的内部结构

objc-runtime-new.h

struct cache_t {
    struct bucket_t *_buckets;  // 散列表
    mask_t _mask;       //散列表的长度-1
    mask_t _occupied;  //已经缓存的方法数量
}


struct bucket_t {
private:
    // IMP-first is better for arm64e ptrauth and no worse for arm64.
    // SEL-first is better for armv7* and i386 and x86_64.
#if __arm64__
    uintptr_t _imp;    //方法实现地址
    SEL _sel;   //sel  作为key
#else
    SEL _sel;
    uintptr_t _imp;
#endif

cache以方法名为 key方法地址为value 缓存。

4.2.1缓存查找实现

bucket_t * cache_t::find(SEL s, id receiver)
{
    assert(s != 0);

    bucket_t *b = buckets();
    mask_t m = mask();
    mask_t begin = cache_hash(s, m);
    mask_t i = begin;
    do {
        if (b[i].sel() == 0  ||  b[i].sel() == s) {
            return &b[i];
        }
    } while ((i = cache_next(i, m)) != begin);

    // hack
    Class cls = (Class)((uintptr_t)this - offsetof(objc_class, cache));
    cache_t::bad_cache(receiver, (SEL)s, cls);
}

static inline mask_t cache_next(mask_t i, mask_t mask) {
    return (i+1) & mask; //找不到就+1再找 这是解决散列冲突最简单的一种实现方式
}

当去查找一个方法是否在缓存中时，就会那这个方法名通过一个散列函数计算出他在buckets数组中的位置然后在&mask就能拿到一个函数的实现地址，

4.2.2缓存添加实现

static void cache_fill_nolock(Class cls, SEL sel, IMP imp, id receiver)
{
    cacheUpdateLock.assertLocked();

    // Never cache before +initialize is done
    if (!cls->isInitialized()) return;

    // Make sure the entry wasn't added to the cache by some other thread 
    // before we grabbed the cacheUpdateLock.
    if (cache_getImp(cls, sel)) return;

    cache_t *cache = getCache(cls);

    // Use the cache as-is if it is less than 3/4 full
    mask_t newOccupied = cache->occupied() + 1;
    mask_t capacity = cache->capacity();
    if (cache->isConstantEmptyCache()) {
        // Cache is read-only. Replace it.
        cache->reallocate(capacity, capacity ?: INIT_CACHE_SIZE);
    }
    else if (newOccupied <= capacity / 4 * 3) {
        // Cache is less than 3/4 full. Use it as-is.
    }
    else {
        // Cache is too full. Expand it.
        cache->expand(); // 缓存扩容，生成一个新的数组大小是现有数组2倍，清空当前方法缓存
    }

    // Scan for the first unused slot and insert there.
    // There is guaranteed to be an empty slot because the 
    // minimum size is 4 and we resized at 3/4 full.
    bucket_t *bucket = cache->find(sel, receiver);
    if (bucket->sel() == 0) cache->incrementOccupied();
    bucket->set<Atomic>(sel, imp);
}

void cache_fill(Class cls, SEL sel, IMP imp, id receiver)
{
#if !DEBUG_TASK_THREADS
    mutex_locker_t lock(cacheUpdateLock);
    cache_fill_nolock(cls, sel, imp, receiver);
#else
    _collecting_in_critical();
    return;
#endif
}

添加缓存首先要查找缓存是否存在，存在则返回，无则添加，当缓存满了的时候就会扩容，扩容后并不会把现有缓存copy到新数组中，而是把现有数组清空。所以每当缓存满了的时候就会，扩容，以前调用的方法都需要重新调用时才会缓存。

下面我们总结一下方法调用的一个整体过程：
1.首先通过isa指针找到类对象然后去类对象的缓存cache中去查找方法,如果查找到该方法则直接调用

2.如果在类对象中未找到方法,则去类对象的方法列表寻找方法,如果找到方法,则调用该方法,同时缓存一份到cache中

3.如果在类对象的cache和方法列表中都没有找到该方法,则通过类对象的superClass指针到父类的类对象的cache中查找,如果找到,则调用该方法,同时缓存一份到自身的类对象的cache中

4.如果在自身的类对象的cache中,方法列表中,父类的cache中都没找到,则到父类的方法列表中查找,如果找到,则调用该方法,同时缓存一 份到父类类对象的cache中,也缓存一份到自己类对象的cache中.

5.如果在父类的方法列表里也找不到该方法,则重复执行4,层层向上查找,直到找到NSObject,如果NSObject都没有,那就会结束 报错，其实当一个方法找不到时并不会立即报错，它会进入消息转发流程，给你三次机会去处理，这下来我们就讲一下这个流程。

五 方法调用及消息转发流程

首先我们先看一段代码：

#include<stdio.h>
#include "Person.h"
#import <Foundation/Foundation.h>
#import <objc/runtime.h>
 int main()
{
    Person *person = [[Person alloc] init];
    [person speak];
}

把它转成c++代码：xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

 int main()
{
    Person *person = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
    ((void (*)(id, SEL))(void *)objc_msgSend)((id)person, sel_registerName("speak"));
}

我们发现objc_msgSend参与了对象创建以及方法调用，OC中的方法调用，其实都是转换为objc_msgSend函数的调用。OC的方法调用就是利用objc_msgSend这种消息机制，给方法调用者发送消息，它有两个参与内容：

1 消息接受者 （receiver）:person

2 消息名称 ：init ,speak

objc_msgSend的执行流程可以分为3大阶段
1 消息发送
2 动态方法解析
3 消息转发
下面我们从源码来分析objc_msgSend执行流程，先看一下大致的执行流程，然后我们在分析每个阶段的流程

objc-msg-arm64.s
ENTRY _objc_msgSend  // 1 进入消息流程
b.le  LNilOrTagged
CacheLookup NORMAL  //查看方法缓存
.macro CacheLookup
.macro CheckMiss
STATIC_ENTRY __objc_msgSend_uncached
.macro MethodTableLookup。  //查找方法
__class_lookupMethodAndLoadCache3

objc-runtime-new.mm
_class_lookupMethodAndLoadCache3
lookUpImpOrForward
getMethodNoSuper_nolock、search_method_list、log_and_fill_cache
cache_getImp、log_and_fill_cache、getMethodNoSuper_nolock、log_and_fill_cache
_class_resolveInstanceMethod。  // 2 动态方法解析
_objc_msgForward_impcache

objc-msg-arm64.s
STATIC_ENTRY __objc_msgForward_impcache
ENTRY __objc_msgForward   //3 进入消息转发
Core Foundation
__forwarding__（不开源）

5.1.1 消息发送

objc_msgSend 的源码实现
ENTRY _objc_msgSend
    UNWIND _objc_msgSend, NoFrame

    cmp p0, #0          //1 消息接收者，receiver  nil check and tagged pointer check
#if SUPPORT_TAGGED_POINTERS
    b.le    LNilOrTagged        // 小于等于零跳转到 LNilOrTagged  (MSB tagged pointer looks negative)
#else
    b.eq    LReturnZero
#endif
    ldr p13, [x0]       // p13 = isa
    GetClassFromIsa_p16 p13     // p16 = class
LGetIsaDone:
    CacheLookup NORMAL      // 2 查找缓存，具体实现看 CacheLookup calls imp or objc_msgSend_uncached

#if SUPPORT_TAGGED_POINTERS
LNilOrTagged:
    b.eq    LReturnZero     // 为空跳转到 LReturnZero nil check

    // tagged
    adrp    x10, _objc_debug_taggedpointer_classes@PAGE
    add x10, x10, _objc_debug_taggedpointer_classes@PAGEOFF
    ubfx    x11, x0, #60, #4
    ldr x16, [x10, x11, LSL #3]
    adrp    x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGE
    add x10, x10, _OBJC_CLASS_$___NSUnrecognizedTaggedPointer@PAGEOFF
    cmp x10, x16
    b.ne    LGetIsaDone

    // ext tagged
    adrp    x10, _objc_debug_taggedpointer_ext_classes@PAGE
    add x10, x10, _objc_debug_taggedpointer_ext_classes@PAGEOFF
    ubfx    x11, x0, #52, #8
    ldr x16, [x10, x11, LSL #3]
    b   LGetIsaDone
// SUPPORT_TAGGED_POINTERS
#endif

LReturnZero:
    // x0 is already zero
    mov x1, #0
    movi    d0, #0
    movi    d1, #0
    movi    d2, #0
    movi    d3, #0
    ret            //return 退出程序

    END_ENTRY _objc_msgSend

.macro CacheLookup
    // p1 = SEL, p16 = isa
    ldp p10, p11, [x16, #CACHE] // 3 查找方法缓存  p10 = buckets, p11 = occupied|mask
#if !__LP64__
    and w11, w11, 0xffff    // p11 = mask
#endif
    and w12, w1, w11        // x12 = _cmd & mask
    add p12, p10, p12, LSL #(1+PTRSHIFT)
                     // p12 = buckets + ((_cmd & mask) << (1+PTRSHIFT))

    ldp p17, p9, [x12]      // {imp, sel} = *bucket
1:  cmp p9, p1          // if (bucket->sel != _cmd)
    b.ne    2f          //     scan more
    CacheHit $0         // 4 缓存查找到就返回函数地址 call or return imp
    
2:  // not hit: p12 = not-hit bucket  // 没有查找到缓存
    CheckMiss $0            // 5 没找到缓存CheckMiss    miss if bucket->sel == 0
    cmp p12, p10        // wrap if bucket == buckets
    b.eq    3f
    ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket
    b   1b          // loop

3:  // wrap: p12 = first bucket, w11 = mask
    add p12, p12, w11, UXTW #(1+PTRSHIFT)
                                // p12 = buckets + (mask << 1+PTRSHIFT)

    // Clone scanning loop to miss instead of hang when cache is corrupt.
    // The slow path may detect any corruption and halt later.

    ldp p17, p9, [x12]      // {imp, sel} = *bucket
1:  cmp p9, p1          // if (bucket->sel != _cmd)
    b.ne    2f          //     scan more
    CacheHit $0         // call or return imp
    
2:  // not hit: p12 = not-hit bucket
    CheckMiss $0            // 6 没有找到则调用CheckMiss  miss if bucket->sel == 0
    cmp p12, p10        // wrap if bucket == buckets
    b.eq    3f
    ldp p17, p9, [x12, #-BUCKET_SIZE]!  // {imp, sel} = *--bucket
    b   1b          // loop

3:  // double wrap
    JumpMiss $0
    
.endmacro

.macro CheckMiss
    // miss if bucket->sel == 0
.if $0 == GETIMP
    cbz p9, LGetImpMiss
.elseif $0 == NORMAL
    cbz p9, __objc_msgSend_uncached    //7 调用__objc_msgSend_uncached
.elseif $0 == LOOKUP
    cbz p9, __objc_msgLookup_uncached
.else
.abort oops
.endif
.endmacro

STATIC_ENTRY __objc_msgSend_uncached
    UNWIND __objc_msgSend_uncached, FrameWithNoSaves

    // THIS IS NOT A CALLABLE C FUNCTION
    // Out-of-band p16 is the class to search
    
    MethodTableLookup  // 8 查找方法表
    TailCallFunctionPointer x17

    END_ENTRY __objc_msgSend_uncached


    STATIC_ENTRY __objc_msgLookup_uncached
    UNWIND __objc_msgLookup_uncached, FrameWithNoSaves

    // THIS IS NOT A CALLABLE C FUNCTION
    // Out-of-band p16 is the class to search
    
    MethodTableLookup
    ret

    END_ENTRY __objc_msgLookup_uncached


    STATIC_ENTRY _cache_getImp

    GetClassFromIsa_p16 p0
    CacheLookup GETIMP

.macro MethodTableLookup
    
    // push frame
    SignLR
    stp fp, lr, [sp, #-16]!
    mov fp, sp

    // save parameter registers: x0..x8, q0..q7
    sub sp, sp, #(10*8 + 8*16)
    stp q0, q1, [sp, #(0*16)]
    stp q2, q3, [sp, #(2*16)]
    stp q4, q5, [sp, #(4*16)]
    stp q6, q7, [sp, #(6*16)]
    stp x0, x1, [sp, #(8*16+0*8)]
    stp x2, x3, [sp, #(8*16+2*8)]
    stp x4, x5, [sp, #(8*16+4*8)]
    stp x6, x7, [sp, #(8*16+6*8)]
    str x8,     [sp, #(8*16+8*8)]

    // receiver and selector already in x0 and x1
    mov x2, x16
    bl  __class_lookupMethodAndLoadCache3  // 9 跳转调用__class_lookupMethodAndLoadCache3

    // IMP in x0
    mov x17, x0
    
    // restore registers and return
    ldp q0, q1, [sp, #(0*16)]
    ldp q2, q3, [sp, #(2*16)]
    ldp q4, q5, [sp, #(4*16)]
    ldp q6, q7, [sp, #(6*16)]
    ldp x0, x1, [sp, #(8*16+0*8)]
    ldp x2, x3, [sp, #(8*16+2*8)]
    ldp x4, x5, [sp, #(8*16+4*8)]
    ldp x6, x7, [sp, #(8*16+6*8)]
    ldr x8,     [sp, #(8*16+8*8)]

    mov sp, fp
    ldp fp, lr, [sp], #16
    AuthenticateLR

.endmacro

10 class_lookupMethodAndLoadCache3 定义
IMP _class_lookupMethodAndLoadCache3(id obj, SEL sel, Class cls)
{
    return lookUpImpOrForward(cls, sel, obj, 
                              YES/*initialize*/, NO/*cache*/, YES/*resolver*/);//cls 类对象, sel 类名, obj 消息接收者, 
}

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)
{
    IMP imp = nil;
    bool triedResolver = NO;

    runtimeLock.assertUnlocked();

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

    // runtimeLock is held during isRealized and isInitialized checking
    // to prevent races against concurrent realization.

    // runtimeLock is held during method search to make
    // method-lookup + cache-fill atomic with respect to method addition.
    // Otherwise, a category could be added but ignored indefinitely because
    // the cache was re-filled with the old value after the cache flush on
    // behalf of the category.

    runtimeLock.lock();
    checkIsKnownClass(cls);

    if (!cls->isRealized()) {
        cls = realizeClassMaybeSwiftAndLeaveLocked(cls, runtimeLock);
        // runtimeLock may have been dropped but is now locked again
    }

    if (initialize && !cls->isInitialized()) {
        cls = initializeAndLeaveLocked(cls, inst, runtimeLock);
        // runtimeLock may have been dropped but is now locked again

        // If sel == initialize, class_initialize will send +initialize and 
        // then the messenger will send +initialize again after this 
        // procedure finishes. Of course, if this is not being called 
        // from the messenger then it won't happen. 2778172
    }


 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;
        }
    }

    // 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); //cls 将父类方法填充到类对像的缓存中
                    goto done;  //找到了跳转 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;    //找到了直接跳转done
            }
        }
    }

    // No implementation found. Try method resolver once.

    if (resolver  &&  !triedResolver) {
        runtimeLock.unlock();
        resolveMethod(cls, sel, inst);   //进入消息转发流程
        runtimeLock.lock();
        // Don't cache the result; we don't hold the lock so it may have 
        // changed already. Re-do the search from scratch instead.
        triedResolver = YES;
        goto retry;
    }

    // No implementation found, and method resolver didn't help. 
    // Use forwarding.

    imp = (IMP)_objc_msgForward_impcache;
    cache_fill(cls, sel, imp, inst);

 done:
    runtimeLock.unlock();

    return imp;  // 返回函数地址
}

objc_msgSend由于调用的频次非常频繁，为了提高执行效率，所以使用了汇编来实现，它的大致实现流程是
1.首先通过isa指针找到类对象然后去类对象的缓存cache中去查找方法,如果查找到该方法则直接调用

2.如果在类对象中未找到方法,则去类对象的方法列表寻找方法,如果找到方法,则调用该方法,同时缓存一份到cache中

3.如果在类对象的cache和方法列表中都没有找到该方法,则通过类对象的superClass指针到父类的类对象的cache中查找,如果找到,则调用该方法,同时缓存一份到自身的类对象的cache中

4.如果在自身的类对象的cache中,方法列表中,父类的cache中都没找到,则到父类的方法列表中查找,如果找到,则调用该方法,同时缓存一 份到父类类对象的cache中,也缓存一份到自己类对象的cache中.

5.如果在父类的方法列表里也找不到该方法,则重复执行4,层层向上查找,直到找到NSObject,如果NSObject都没有,那就会进入动态方法解析。执行流程图如下：

objc_msgSend 消息发送流程

讲完了objc_msgSend 消息发送流程，接下来我们讲下 动态方法解析流程。

5.1.2 动态方法解析

先看一下底层实现源码：

我们截取了上面lookUpImpOrForward中的一段代码
 if (resolver  &&  !triedResolver) {
        runtimeLock.unlock();
        resolveMethod(cls, sel, inst);
        runtimeLock.lock();
        // Don't cache the result; we don't hold the lock so it may have 
        // changed already. Re-do the search from scratch instead.
        triedResolver = YES;
        goto retry;  //重新走查找方法流程
    }

static void resolveMethod(Class cls, SEL sel, id inst)
{
    runtimeLock.assertUnlocked();
    assert(cls->isRealized());

    if (! cls->isMetaClass()) { //如果不是元类对象
        // try [cls resolveInstanceMethod:sel]
        resolveInstanceMethod(cls, sel, inst); //调用resolveInstanceMethod
    } 
    else {
        // try [nonMetaClass resolveClassMethod:sel]
        // and [cls resolveInstanceMethod:sel]
        resolveClassMethod(cls, sel, inst); //否则调用resolveClassMethod
        if (!lookUpImpOrNil(cls, sel, inst, 
                            NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
        {
            resolveInstanceMethod(cls, sel, inst);
        }
    }
}

static void resolveInstanceMethod(Class cls, SEL sel, id inst)
{
    runtimeLock.assertUnlocked();
    assert(cls->isRealized());

    if (! lookUpImpOrNil(cls->ISA(), SEL_resolveInstanceMethod, cls, 
                         NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
    {
        // Resolver not implemented.
        return;
    }

    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(cls, SEL_resolveInstanceMethod, sel); //那当前类对象调用resolveInstanceMethod

    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveInstanceMethod adds to self a.k.a. cls
    IMP imp = lookUpImpOrNil(cls, sel, inst, 
                             NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

    if (resolved  &&  PrintResolving) {
        if (imp) {
            _objc_inform("RESOLVE: method %c[%s %s] "
                         "dynamically resolved to %p", 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel), imp);
        }
        else {
            // Method resolver didn't add anything?
            _objc_inform("RESOLVE: +[%s resolveInstanceMethod:%s] returned YES"
                         ", but no new implementation of %c[%s %s] was found",
                         cls->nameForLogging(), sel_getName(sel), 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel));
        }
    }
}

static void resolveClassMethod(Class cls, SEL sel, id inst)
{
    runtimeLock.assertUnlocked();
    assert(cls->isRealized());
    assert(cls->isMetaClass());

    if (! lookUpImpOrNil(cls, SEL_resolveClassMethod, inst, 
                         NO/*initialize*/, YES/*cache*/, NO/*resolver*/)) 
    {
        // Resolver not implemented.
        return;
    }

    Class nonmeta;
    {
        mutex_locker_t lock(runtimeLock);
        nonmeta = getMaybeUnrealizedNonMetaClass(cls, inst);
        // +initialize path should have realized nonmeta already
        if (!nonmeta->isRealized()) {
            _objc_fatal("nonmeta class %s (%p) unexpectedly not realized",
                        nonmeta->nameForLogging(), nonmeta);
        }
    }
    BOOL (*msg)(Class, SEL, SEL) = (typeof(msg))objc_msgSend;
    bool resolved = msg(nonmeta, SEL_resolveClassMethod, sel);//拿当前元类对象调用resolveClassMethod

    // Cache the result (good or bad) so the resolver doesn't fire next time.
    // +resolveClassMethod adds to self->ISA() a.k.a. cls
    IMP imp = lookUpImpOrNil(cls, sel, inst, 
                             NO/*initialize*/, YES/*cache*/, NO/*resolver*/);

    if (resolved  &&  PrintResolving) {
        if (imp) {
            _objc_inform("RESOLVE: method %c[%s %s] "
                         "dynamically resolved to %p", 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel), imp);
        }
        else {
            // Method resolver didn't add anything?
            _objc_inform("RESOLVE: +[%s resolveClassMethod:%s] returned YES"
                         ", but no new implementation of %c[%s %s] was found",
                         cls->nameForLogging(), sel_getName(sel), 
                         cls->isMetaClass() ? '+' : '-', 
                         cls->nameForLogging(), sel_getName(sel));
        }
    }
}

1 前面的消息发送没有找到要调用的方法就会调用 resolveMethod(cls, sel, inst)
2 resolveMethod(cls, sel, inst)内部做了议程判断
* 如果是元类对象则调用resolveClassMethod(cls, sel, inst);
*否则调用：resolveInstanceMethod(cls, sel, inst);
3 resolveClassMethod(cls, sel, inst); 内部则是拿当前的元类对象调用resolveClassMethod方法，所以我们要进行消息处理则要在类里实现这个方法

+ (BOOL)resolveInstanceMethod:(SEL)sel{
    if(sel == @selector(eat)){
        Method method = class_getInstanceMethod(self, @selector(other));
        class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
        return YES;
        
    }
    return [super resolveInstanceMethod:<#sel#>];
}

4 resolveInstanceMethod(cls, sel, inst) 内部这是拿当前的类对象调用resolveInstanceMethod方法同理我们要进行消息处理则要在类里实现这个方法

+ (BOOL)resolveClassMethod:(SEL)sel{
    if(sel == @selector(eat)){
           Method method = class_getInstanceMethod(self, @selector(other));
           class_addMethod(self, sel, method_getImplementation(method), method_getTypeEncoding(method));
           return YES;
           
       }
       return [super resolveClassMethod:<#sel#>];
}

最后看一下它的执行流程图：

消息处理流程

动态解析过后，会重新走“消息发送”的流程
“从receiverClass的cache中查找方法”这一步开始执行，如果开发者详细处理的两个方法都没有实现，会怎么办呢，那么他就会走接下来的消息转发流程。

5.1.3 消息转发

lookUpImpOrForward接近最后两行代码

  imp = (IMP)_objc_msgForward_impcache;  //执行__objc_msgForward_impcache
  cache_fill(cls, sel, imp, inst);

objc-msg-arm64.s

STATIC_ENTRY __objc_msgForward_impcache

    // No stret specialization.
    b   __objc_msgForward

    END_ENTRY __objc_msgForward_impcache

    
    ENTRY __objc_msgForward

    adrp    x17, __objc_forward_handler@PAGE
    ldr p17, [x17, __objc_forward_handler@PAGEOFF]  //执行__objc_forward_handler
    TailCallFunctionPointer x17
    
    END_ENTRY __objc_msgForward

STATIC_ENTRY __objc_msgForward_impcache

    // No stret specialization.
    b   __objc_msgForward //执行__objc_msgForward

    END_ENTRY __objc_msgForward_impcache

//为代码
int __forwarding__(void *frameStackPointer, int isStret) {
    id receiver = *(id *)frameStackPointer;
    SEL sel = *(SEL *)(frameStackPointer + 8);
    const char *selName = sel_getName(sel);
    Class receiverClass = object_getClass(receiver);

    // 调用 forwardingTargetForSelector:
    if (class_respondsToSelector(receiverClass, @selector(forwardingTargetForSelector:))) {
        id forwardingTarget = [receiver forwardingTargetForSelector:sel];
        if (forwardingTarget && forwardingTarget != receiver) {
            if (isStret == 1) {
                int ret;
                objc_msgSend_stret(&ret,forwardingTarget, sel, ...);
                return ret;
            }
            return objc_msgSend(forwardingTarget, sel, ...);
        }
    }

    // 僵尸对象
    const char *className = class_getName(receiverClass);
    const char *zombiePrefix = "_NSZombie_";
    size_t prefixLen = strlen(zombiePrefix); // 0xa
    if (strncmp(className, zombiePrefix, prefixLen) == 0) {
        CFLog(kCFLogLevelError,
              @"*** -[%s %s]: message sent to deallocated instance %p",
              className + prefixLen,
              selName,
              receiver);
        <breakpoint-interrupt>
    }

    // 调用 methodSignatureForSelector 获取方法签名后再调用 forwardInvocation
    if (class_respondsToSelector(receiverClass, @selector(methodSignatureForSelector:))) {
        NSMethodSignature *methodSignature = [receiver methodSignatureForSelector:sel];
        if (methodSignature) {
            BOOL signatureIsStret = [methodSignature _frameDescriptor]->returnArgInfo.flags.isStruct;
            if (signatureIsStret != isStret) {
                CFLog(kCFLogLevelWarning ,
                      @"*** NSForwarding: warning: method signature and compiler disagree on struct-return-edness of '%s'.  Signature thinks it does%s return a struct, and compiler thinks it does%s.",
                      selName,
                      signatureIsStret ? "" : not,
                      isStret ? "" : not);
            }
            if (class_respondsToSelector(receiverClass, @selector(forwardInvocation:))) {
                NSInvocation *invocation = [NSInvocation _invocationWithMethodSignature:methodSignature frame:frameStackPointer];

                [receiver forwardInvocation:invocation];

                void *returnValue = NULL;
                [invocation getReturnValue:&value];
                return returnValue;
            } else {
                CFLog(kCFLogLevelWarning ,
                      @"*** NSForwarding: warning: object %p of class '%s' does not implement forwardInvocation: -- dropping message",
                      receiver,
                      className);
                return 0;
            }
        }
    }

    SEL *registeredSel = sel_getUid(selName);

    // selector 是否已经在 Runtime 注册过
    if (sel != registeredSel) {
        CFLog(kCFLogLevelWarning ,
              @"*** NSForwarding: warning: selector (%p) for message '%s' does not match selector known to Objective C runtime (%p)-- abort",
              sel,
              selName,
              registeredSel);
    } // doesNotRecognizeSelector
    else if (class_respondsToSelector(receiverClass,@selector(doesNotRecognizeSelector:))) {
        [receiver doesNotRecognizeSelector:sel];
    }
    else {
        CFLog(kCFLogLevelWarning ,
              @"*** NSForwarding: warning: object %p of class '%s' does not implement doesNotRecognizeSelector: -- abort",
              receiver,
              className);
    }

    // The point of no return.
    kill(getpid(), 9);
}

最终我们发现它会调用两个方法：
1 forwardingTargetForSelector: 返回yes 执行objc_msgSend(返回值, SEL ）返回nil这执行第二步
2 methodSignatureForSelector //方法签名如果这个方法有返回值的话这会执行下一步
3 (void)forwardInvocation:(NSInvocation *)anInvocation //NSInvocation封装了一个方法调用，包括，调用者，方法名，方法参数，只要能进入到这个方法，它里面的实现可以随便写，哪怕打印一句话也行或者任何处理也没有也行。
消息转发调用流程图如下：

消息转发调用流程

1 苹果的文档里，讲述了这一个消息转发的出发点，其实是为了实现类似C多继承的功能。我们知道，在C中如果一个类想要具有多个类的功能，是可以直接继承多个类的。而Objective-C是单继承，如果想实现类似的功能，就用消息转发，将消息转发给有能力处理的类。苹果是这样描述他们的思想的：C的多继承，是加法，在多继承的同时，其实也增加了很多不需要的功能，而苹果通过消息转发，实现了减法的思想，只留有用的方法，而不去增加过多内容。
2 开发者可以在forwardInvocation:方法中自定义任何逻辑
3 以上方法都有对象方法、类方法2个版本（前面可以是加号+，也可以是减号-）

- (id)forwardingTargetForSelector:(SEL)aSelector{
    if(aSelector == @selector(eat)) {
        return [[Person alloc] init];//将eat方法j转交给Person对象执行，person要实现eat方法
    }
    return [super forwardingTargetForSelector:aSelector];
}
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if(aSelector == @selector(eat)) {
        return [NSMethodSignature signatureWithObjCTypes:"v@:"];
    }
    return [super methodSignatureForSelector:aSelector];
}

- (void)forwardInvocation:(NSInvocation *)anInvocation{
    
}


+ (id)forwardingTargetForSelector:(SEL)aSelector{
    if(aSelector == @selector(eat)) {
        return [[Person alloc] init];//将eat方法j转交给Person对象执行，person要实现eat方法
    }
    return [super forwardingTargetForSelector:aSelector];
}

+ (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector{
    if(aSelector == @selector(eat)) {
         NSMethodSignature *signature = [[[Person alloc] init] methodSignatureForSelector:@selector(eat)];
        return signature;
       }
       return [super methodSignatureForSelector:aSelector];
}
+ (void)forwardInvocation:(NSInvocation *)anInvocation{
    anInvocation.target;
    anInvocation.selector;
    [anInvocation getArgument:NULL atIndex:2];// 第三个参数才是你的方法参数，前两个是方法的默认参数
    [anInvocation invoke];
}

六 runtime常用api

6.1类

• 动态创建一个类（参数：父类，类名，额外的内存空间）
  Class objc_allocateClassPair(Class superclass, const char *name, size_t extraBytes)

*注册一个类（要在类注册之前添加成员变量）
void objc_registerClassPair(Class cls)

*销毁一个类
void objc_disposeClassPair(Class cls)

*获取isa指向的Class
Class object_getClass(id obj)

*设置isa指向的Class
Class object_setClass(id obj, Class cls)

*判断一个OC对象是否为Class
BOOL object_isClass(id obj)

*判断一个Class是否为元类
BOOL class_isMetaClass(Class cls)

*获取父类
Class class_getSuperclass(Class cls)

6.2成员变量

*获取一个实例变量信息
Ivar class_getInstanceVariable(Class cls, const char *name)

*拷贝实例变量列表（最后需要调用free释放）
Ivar *class_copyIvarList(Class cls, unsigned int *outCount)

*设置和获取成员变量的值
void object_setIvar(id obj, Ivar ivar, id value)
id object_getIvar(id obj, Ivar ivar)

*动态添加成员变量（已经注册的类是不能动态添加成员变量的）
BOOL class_addIvar(Class cls, const char * name, size_t size, uint8_t alignment, const char * types)

*获取成员变量的相关信息
const char *ivar_getName(Ivar v)
const char *ivar_getTypeEncoding(Ivar v)

6.3属性

*获取一个属性
objc_property_t class_getProperty(Class cls, const char *name)

*拷贝属性列表（最后需要调用free释放）
objc_property_t *class_copyPropertyList(Class cls, unsigned int *outCount)

*动态添加属性
BOOL class_addProperty(Class cls, const char *name, const objc_property_attribute_t *attributes,
unsigned int attributeCount)

*动态替换属性
void class_replaceProperty(Class cls, const char *name, const objc_property_attribute_t *attributes,
unsigned int attributeCount)

*获取属性的一些信息
const char *property_getName(objc_property_t property)
const char *property_getAttributes(objc_property_t property)

6.4方法

*获得一个实例方法、类方法
Method class_getInstanceMethod(Class cls, SEL name)
Method class_getClassMethod(Class cls, SEL name)

*方法实现相关操作
IMP class_getMethodImplementation(Class cls, SEL name)
IMP method_setImplementation(Method m, IMP imp)
void method_exchangeImplementations(Method m1, Method m2)

*拷贝方法列表（最后需要调用free释放）
Method *class_copyMethodList(Class cls, unsigned int *outCount)

*动态添加方法
BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types)

*动态替换方法
IMP class_replaceMethod(Class cls, SEL name, IMP imp, const char *types)

*获取方法的相关信息（带有copy的需要调用free去释放）
SEL method_getName(Method m)
IMP method_getImplementation(Method m)
const char *method_getTypeEncoding(Method m)
unsigned int method_getNumberOfArguments(Method m)
char *method_copyReturnType(Method m)
char *method_copyArgumentType(Method m, unsigned int index)
*选择器相关
const char *sel_getName(SEL sel)
SEL sel_registerName(const char *str)

*用block作为方法实现
IMP imp_implementationWithBlock(id block)
id imp_getBlock(IMP anImp)
BOOL imp_removeBlock(IMP anImp)
到此我们整个runtime基本知识都以经讲完了，下面我们来看一下runtime在实际开发中的应用

七 runtime开发中具体应用

runtime的应用，主要有几种：

• 1 AOP,切面编程，做打点
• 2 method swizzling,黑魔法做崩溃等的保护
• 3 利用关联对象（AssociatedObject）给分类添加属性
• 4 遍历类的所有成员变量（修改textfield的占位文字颜色、字典转模型、自动归档解档）
• 5 交换方法实现（交换系统的方法）
  我们下面举两个例子来讲一下

7.1 Method Swizzling

通过修改一个已存在类的方法, 来实现方法替换是比较常用的runtime技巧.

如在UIView的load方法中:

+ (void)load {
     Method origin = class_getInstanceMethod([UIView class], @selector(touchesBegan:withEvent:));
     Method custom = class_getInstanceMethod([UIView class], @selector(custom_touchesBegan:withEvent:));
     method_exchangeImplementations(origin, custom);
}

- (void)custom_touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
     // TODO
}

这样, 想要触发UIView的touchesBegan:withEvent:方法时, 实际调用的却是自定义的custom_touchesBegan:withEvent:方法.

另外, 关于runtime method swizzling的一个使用场景, 请参考博客:

iOS — 使用runtime解决3D Touch导致UIImagePicker崩溃的问题

7.2 关联对象

Objective-C中的Category无法向既有的类添加属性, 因此可以使用runtime的关联对象(associated objects)来实现.

如将一个字符串关联到一个数组:

static char overviewKey;
NSArray *array = [[NSArray alloc] initWithObjects:@"1", @"2", @"3", nil];
// 为了演示的目的，使用initWithFormat:来确保字符串可以被销毁
NSString *overview = [[NSString alloc] initWithFormat:@"@", @"first three numbers"];
objc_setAssociatedObject(array, &overviewKey, overview, OBJC_ASSOCIATION_RETAIN);

这样, 当overview被手动释放时, 却不会被销毁. 因为关联策略指明了数组array要保有相关联的对象.

而array也释放时, overview才会被销毁.

设置关联对象, 指定被关联对象array, 关联关键字overviewKey, 关联对象overview即可:

objc_setAssociatedObject(array, &overviewKey, overview, OBJC_ASSOCIATION_RETAIN);

获取关联对象, 需要传递被关联对象array和关联关键字overviewKey:

NSString *associatedObject = (NSString *)objc_getAssociatedObject(array, &overviewKey);

断开关联, 只需要设置关联对象为nil即可, 关联策略就无所谓了.

objc_setAssociatedObject(array, &overviewKey, nil, OBJC_ASSOCIATION_ASSIGN);

使用objc_removeAssociatedObjects可断开所有关联, 把对象恢复至原始状态.

相关面试题目
iOS开发之Runtime常用示例