浅析Block的内部结构 , 及分析其是如何利用 NSInvocation 进行调用

Block经过Clang编译器编译成C++语言后，能够看到它实际上是一个结构体。结构及成员变量的构成以下图所示：

Block的结构中首地址指向的就是isa指针，所以Blcok其实也是咱们OC中的对象。经过编译器的处理成C++底层的代码时，Block就是一个结构体，其代码结构以下

struct __main_block_impl_0 {

    // impl结构体   
    struct __block_impl {
            void *isa;  //block的isa指针
            int Flags; //位移枚举标记（标记desc中有无 copy , dispose方法，有无方法签名字符 Signature 等...）
            int Reserved;
            void *FuncPtr; //实现block的功能函数
    } impl ;

    
    struct __main_block_desc_0  {

           size_t reserved;
          size_t Block_size; //block 的 内存大小

          /** 如下两个函数是在 isa 指针指向 _NSConcreteMallocBlock时才会有 **/
          void (*copy)(void); 
          void (*dispose)(void);

            /** 如下字符串是在impl.flag 包含（(1 << 30)这个值是才有的变量），对应oc中的方法签名NSMethodSignature**/
          const char *signatureStr; 
    } * Desc;

     /**  如下都是block捕获的变量 ，变量顺序和是否捕获进来根据block的定义来决定 ，这里只是简单举例**/
    struct __Block_byref_var_0 *var ; // __block变量
    TestClass *__strong strongTestVar ; // strong 变量
    TestClass *__weak weakTestVar ; // weak 变量
    int a ; //局部普通数据类型
    int *b ;//局部静态变量
    /**全局静态变量是直接经过变量的地址访问的不须要捕获进来*/ 
}
复制代码

isa - Block 的类型（isa指针的指向）分为 3种

1. _NSConcreteStackBlock: 只用到外部局部变量 , 且没有强指针引用的block , 其实质上就是函数栈上的局部变量，在当前函数调用完后:（恢复栈空间的时候），就会被释放掉。
2. _NSConcreteGlobalBlock: 彻底没有用到外部变量 ，或只用到全局变量、静态变量的block ，生命周期从建立到应用程序结束。

PS : Block 访问全局变量或静态变量 都是经过捕获他们的地址进行内容访问的，由于这些变量从定义的那一刻开始就肯定了其地址，所以能够经过指针传递来捕获到block内部进行访问。而捕获普通局部变量就不同，局部变量在函数返回后其内存有可能会被会回收掉，因此是不能经过捕获局部变量的地址到block访问的而是经过值传递来传进block内部

3. _NSConcreteMallocBlock (估计是咱们最常解除的block类型了) ：特色是有强指针引用，或者被带有copy修饰的属性引用，或者做为函数返回值返回时。

Flags : 这是一个位移枚举的变量，标记着block的一些属性，好比

• 结构体的Desc中有无 copy个 dispose函数 （1 << 25）
• 结构体的Desc中有无 signatureStr type encodings （char * 类型字符串） （1<<30）
• ......

FuncPtr : 就是你定义block的内部逻辑实现函数的指针。经过编译器把OC的代码处理成c语言的函数后在block初始化时，用这个变量记录函数的指针地址，当block被调用时就是执行这个函数指针指向的函数。

Desc. Block_size : block的内存占用空间的大小

Desc -> copy + dispose 函数 ：block用于管理自身内存的函数

......

更详细的 block底层源码实现 以及 __block变量的原理 推荐阅读 深刻研究Block捕获外部变量和__block实现原理 这篇文章

清楚了Block的内部结构后，咱们来看下如何理由 NSInvocation进行调 用。

NSInvocation是一个OC中用来封装消息发送的类，在Runtime的消息转发的最后一个转发步骤（Normal Forwarding）也有出现 NSInvocation 。 Normal Forwarding 首先调用 - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector这个方法，向调用者返回一个selector 对应的方法签名类 NSMethodSignature对象,若是没有返回NSMethodSignature这个类对象的话 就会抛出找不到方法的错误，不然，就会利用返回的 NSMethodSignature对象 生成一个NSInvocation对象传进- (void)forwardInvocation:(NSInvocation *)anInvocation 方法中完成消息转发机制的最后一步。

首先根据上面分析的Block内部定义一个结构体 ，方便咱们对block进行内部访问。

struct BlockLayout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct block_descriptor {
        unsigned long int reserved;
        unsigned long int size;
        void (*copy)(void *dst, void *src);     // (1<<25)
        void (*dispose)(void *src);
        const char *signature;                         // (1<<30)
    } *descriptor;
    // 捕获的变量
};

enum {
    DescFlagsHasCopyDispose = (1 << 25),
    DescFlagsIsGlobal = (1 << 28),
    DescFlagsHasSignature = (1 << 30)
};
typedef int BlockDescFlags;

复制代码

而后定义一个简单的block

void(^testBlock)(int a , int b) = ^(int a , int b){
         NSLog(@"成功调用了 block");
         NSLog(@"参数1 -> a = %d , 参数2 -> b = %d" , a , b);
};
复制代码

下面开始对Block内部进行访问,获取去signature（const char * ）后生成NSInvoction并传参调用。

//强转为自定义的block结构体指针
    struct BlockLayout * blockLayoutPointer =  (__bridge struct BlockLayout *)testBlock;
    int flags = blockLayoutPointer -> flags;
    
    if (flags & BlockDescFlagsHasSignature) { //有signature字符串
        
        void * signaturePoint = blockLayoutPointer -> descriptor;
        signaturePoint += sizeof(unsigned long int); //reserved
        signaturePoint += sizeof(unsigned long int); //size
        if (flags & BlockDescFlagsHasCopyDispose) {
             signaturePoint += sizeof(void (*)(void *dst , void *src)); //copy
             signaturePoint += sizeof(void (*)(void *src)); //dispose
        }
        
        //拿到 signature 字符串内容
        const char * signatureStr = (* (const char **) signaturePoint);
        NSMethodSignature * blockSignature = [NSMethodSignature signatureWithObjCTypes:signatureStr];
        NSInvocation * invocation = [NSInvocation invocationWithMethodSignature:blockSignature];
        invocation.target = testBlock;
        
        
        //将要传紧block的参数
        int param1 = 10 ;
        int param2 = 20 ;
        
        // block（type encodeings 为 @？） 对应的 NSInvocation 第一个参数为 block自己
        // SEL(type encodeings 为 :) 对应的 NSInvocation 第一个参数为 selector 的 调用者（targat  type encodeings 为 @） ,第二个参数这是 _cmd (方法自己类型为SEL)
        [invocation setArgument:&param1 atIndex:1];
        [invocation setArgument:&param2 atIndex:2];
        
        [invocation invoke];
    }
复制代码

看下打印 ，成功地利用NSInvocation对象调用了 Block。

2018-09-03 15:10:55.182181+0800 BlockWithNSInvocation[10694:872743] 成功调用了 block
2018-09-03 15:10:55.182430+0800 BlockWithNSInvocation[10694:872743] 参数1 -> a = 10 , 参数2 -> b = 20
Program ended with exit code: 0
复制代码

关于类型强转

类型强转其实并无改变目标变量的实际内存的数据，类型强转其实就是告诉编译器 目标变量 是我强转的类型数据，你对这个变量访问时按照我指定的变量类型来访问便可。