Runtime(7)---block原理

block的本质

block是我们很熟悉也是项目中经常用到的东西。block本质上也是一个OC对象，它内部也有个isa指针。block是封装了函数调用以及函数调用环境的OC对象。

block的种类

根据内存的区域分为三种block：全局区block，栈区block，堆区block。

block类型	环境
NSGlobalBlock	没有访问auto变量(访问了全局变量或者static修饰的变量也还是glablBlock)
NSStackBlock	访问了auto变量
NSMallocBlock	NSStackBlock调用了copy

在ARC中打印一下三种blcok

- (void)viewDidLoad {
    [super viewDidLoad];
    
    void(^block)(void) = ^{
    };
    NSLog(@"--%@----",[block class]);
    
    int a = 10;
    void(^block1)(void) = ^{
        NSLog(@"--%d----",a);
    };
    NSLog(@"--%@----",[block1 class]);
    
    NSLog(@"--%@----",[ ^{ NSLog(@"--%d----",a); } class]);
    
}

401604572798_.pic.jpg

block的原理(以下block均是在堆上的)

我们在main.m中写如下代码

int main(int argc, char * argv[]) {
    @autoreleasepool {
         int a = 10;
        //  static int a = 10;
        void(^block1)(void) = ^{
            NSLog(@"--%d----",a);
        };
        block1();
    }
    return 0;
}

将Objective-C代码转换为C\C++代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc OC源文件 -o 输出的CPP文件
也可以省略输出xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m
可以看到直接生成了一个main.cpp文件

打开mian.cpp文件，直接看最后，(相关的地方我归结到一起，做了一点注释。)

// block中的impl成员
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
// block的数据结构
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
//int *a; 捕获static类型的变量
 // block内部生成一个变量a用来捕获外部a的值  FuncPtr来指向方法块
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a (int *_a 捕获static类型的变量), int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
// block指向的方法块
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy
   NSLog((NSString *)&__NSConstantStringImpl__var_folders_7__zp7tv46d1jv7n7n_nyxhrrlw0000gn_T_main_ecd31b_mi_0,a);
/*捕获是static类型变量
int *a = __cself->a; // bound by copy
  NSLog((NSString *)&__NSConstantStringImpl__var_folders_7__zp7tv46d1jv7n7n_nyxhrrlw0000gn_T_main_3aa38c_mi_0,(*a));*/
  }

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

// 这里是我们oc中main函数的部分
int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        int a = 10;
     //  static int a = 10; 外部是static类型变量
        /* 从这里可以看出block是__main_block_impl_0这个对象
           传入了三个对像__main_block_func_0，__main_block_desc_0_DATA，a
         */
        void(*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

// void(*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));  捕获static类型变量的传值
        /*
         block的执行
         */
        ((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
    }
    return 0;
}

这是block内部使用auto变量和static变量时，block内部逻辑的代码情况。

然后我们再看下block访问__block修饰的变量

int main(int argc, char * argv[]) {
    @autoreleasepool {
        
        __block int a = 10;
                
        void(^block1)(void) = ^{
            NSLog(@"--%d----",a);
        };
        block1();
    }
    return 0;
}

重新clang一下看下代码

// 被__block修饰会生成了一个__Block_byref_的结构体
struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_a_0 *a; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a; // bound by ref
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_7__zp7tv46d1jv7n7n_nyxhrrlw0000gn_T_main_8abca0_mi_0,(a->__forwarding->a));
}

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};


int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
// 构造结构体，让__Block_byref_a_0内部的__forwarding指向指针a的地址&a，__Block_byref_a_0内部的a保存外部a的值10.
        __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};

        void(*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
    }
    return 0;
}

对比可以看出，被访问__block修饰的变量，block里生成了一个__Block_byref_a_0的结构体。让__Block_byref_a_0内部的__forwarding指向指针a的地址&a，__Block_byref_a_0内部的a保存外部a的值10.而且在main函数里去构造生成了这个结构体，并把这个结构体变量传到block内部。

同时还增加了两个方法
__main_block_copy_0和__main_block_dispose_0
这两个方法的调用时机是：
__main_block_copy_0：
当block被拷贝到堆上是，如果block内部捕获了引用类型的变量。
1.block内部会调用__main_block_copy_0函数
2.copy函数内部会调用_Block_object_assign函数
3._Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用
__main_block_dispose_0:
当block从堆上移除，如果block内部捕获了引用类型的变量。
1.会调用block内部的dispose函数
2.dispose函数内部会调用_Block_object_dispose函数
3._Block_object_dispose函数会自动释放引用的auto变量（release）

这两个方法，其实是block内部只要捕获了引用类型的变量就会生成的。上边的 int a也会生成，主要是因为被__block修饰后在block内部捕获的时候发生变化了。变成了一个__Block_byref_a_0的结构体变量，这个时候block内部捕获的本质上是一个引用类型。
我们修改一下代码，可以看下正常捕获引用类型的逻辑。

int main(int argc, char * argv[]) {
    @autoreleasepool {
        
        NSObject *per;
        per = [[NSObject alloc]init];
        void(^block1)(void) = ^{
            NSLog(@"--%@----",per);
        };
        block1();
    }
    return 0;
}

clang一下

// block中的impl成员
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  NSObject *per;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *_per, int flags=0) : per(_per) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  NSObject *per = __cself->per; // bound by copy

            NSLog((NSString *)&__NSConstantStringImpl__var_folders_7__zp7tv46d1jv7n7n_nyxhrrlw0000gn_T_main_312725_mi_0,per);
        }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->per, (void*)src->per, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->per, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        NSObject *per;
        per = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));
        void(*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, per, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);
    }
    return 0;
}

同样也可以看到__main_block_copy_0和__main_block_dispose_0这两个方法。可见只有捕获到引用类型的时候才会有。

而且细心点我们也会发现
一：如果判断能不能对捕获的对象进行修改(意思就是从新指向一块新的内存地址)，可以直接在((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, per, 570425344));向block里传值的这个地方看出来。看捕获的对象传的是什么，是&per还是per，如果传的是&per指针的地址，就可以让指针重新指向一块新的地址，修改捕获的对象。如果传的是per，也就是对象，也可以说对象的地址，这样就没法去修改自己的地址了，总不能自己覆盖自己，这样怎么让指针就指到这个新地址呢。所以从这个地方我们也能看出对捕获的对象进行修改和不能进行修改的区别。从上面的逻辑代码我们也能看出对static和__block修饰的变量是可以进行修改的。
二：在__main_block_impl_0中我们可以看到它的impl.isa = &_NSConcreteStackBlock;是不是很奇怪，它的isa尽然指向了栈区block，这显然和我们的想法不同。其实很正常，我们clang的C++代码只是编译时期的，block的最终类型肯定是在运行时来决定了，我们当前的环境是在ARC下的，而在ARC中赋值的时候block会自动把栈区的copy到堆区。
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m我们也可以这样制定clang的状态。

补充一点

MRC下block属性的建议写法
@property (copy, nonatomic) void (^block)(void);

ARC下block属性的建议写法（因为ARC环境下回自动copy，所以strong，copy修饰都一样）
@property (strong, nonatomic) void (^block)(void);
@property (copy, nonatomic) void (^block)(void);