Blocks的学习

Block的分类

Block根据其类型可以分为三类：

• 全局Block（NSGlobalBlock）
• 栈Block（NSMallocBlock）
• 堆Block（NSStackBlock）

而其区分的规则为：

如果没有引用局部变量，或者只引用了静态变量和全局变量，则为全局Block，如果内部有使用局部变量，如果有被强指针引用过，就是堆Block，如果没有则为栈Block。

- (void)func2 {/**— 全局block，没有使用局部变量，或者只使用了静态变量或者只使用了全局变量*/// 没有使用局部变量NSLog(@"block0 - %@",^{});// 使用了静态变量void(^block1)(void) = ^{blockInt = 3;};NSLog(@"block1 - %@",block1);/**- 堆Block 使用局部变量 并且用强指针引用过*/// 即使用局部变量又使用，静态变量NSInteger i = 1;void(^block2)(void) = ^{NSLog(@"block %ld", i);NSLog(@"block static %d", blockInt);};NSLog(@"block2 - %@",block2);// 只使用局部变量void(^block3)(void) = ^{NSLog(@"block %ld", i);};NSLog(@"block3 - %@",block3);// 使用强指针引用过，再使用若指针引用void(^ __weak block4)(void) = block3;NSLog(@"block4 - %@",block4);/**- 栈Block 没有被强引用过的*/// 没有使用强指针引用过void (^__weak block5)(void) = ^{NSLog(@"block %ld", i);};NSLog(@"block5 - %@",block5);
}

分析：
block0 : 没有使用任何变量，属于全局block。
block1 : 只使用了静态变量blockInt，属于全局block。
block2 : 使用了局部变量和静态变量，并且有被strong引用过，属于堆block
block3 : 使用了局部变量i，并且有被strong引用过，属于堆block
block4 : 虽然被weak指针引用的，但其已经被strong引用过，属于堆block
block5 : 没有被strong指针引用过。即使使用了局部变量，属于栈block

Block本质

可以将block代码通过clang 重写为C++代码，看其底层实现

int object_c_origin_block() {NSObject *obj = [[NSObject alloc] init];void(^ block)(void) = ^ {NSLog(@"%@",obj);};block();return 0;
}

重写命令

xcrun -sdk iphoneos clang -rewrite-objc <OriginFile> -o <CppFile>

得到Block结构的定义：

struct __object_c_origin_block_block_impl_0 {struct __block_impl impl;struct __object_c_origin_block_block_desc_0* Desc;NSObject *obj;__object_c_origin_block_block_impl_0(void *fp, struct __object_c_origin_block_block_desc_0 *desc, NSObject *_obj, int flags=0) : obj(_obj) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};struct __block_impl {void *isa;int Flags;int Reserved;void *FuncPtr;
};

从重写的结果，我们可以得到Block的以下特点：

• block出生就是在栈上（isa指针指向_NSConcreteStackBlock）
• block有捕获变量的能力（__object_c_origin_block_block_impl_0内部有obj变量）
• block也是个对象（存在isa指针）

Block循环引用

在使用Block的时候，最容易出现的问题就是循环引用，尤其是在mvvm架构中，Controller引用ViewModel，ViewModel引用Block，有的Block的复制在Controller里面完成，有可能会捕获到Controller，从而造成循环引用。

- (void)bindViewModel {self.viewModel.refreshViewCallBack = ^(void) {[self.tableView reloadData];};
}

而解决循环引用有以下几种办法：

__weak __strong协作

- (void)bindViewModel01 {__weak typeof(self) weakSelf = self;self.viewModel.refreshViewCallBack = ^{__strong typeof(weakSelf) strongSelf = weakSelf;[strongSelf.tableView reloadData];};
}

block对象，并没有引用self，在执行block的时候strongSelf的生命周期只有在block内部，在block内部，self的引用计数+1，当执行完block，引用计数-1。既没有引起循环引用，又适当延长了self的生命周期，一举双得。

__block

- (void)bindViewModel02 {__block Controller *blockSelf = self;self.viewModel.refreshViewCallBack = ^{[blockSelf.tableView reloadData];blockSelf = nil;};
}

使用这种方式，同样也可以解决循环引用，但是要注意，block执行完一次，下一次执行之前记得要给blockSelf重新复制，不然会出问题，显然维护这个是非常麻烦的，所以不推荐。

参数传递

- (void)bindViewModel03 {self.viewModel.refreshViewBlcok = ^(OSMVVMViewController * _Nonnull vc) {[vc.tableView reloadData];};self.viewModel.refreshViewBlcok(self);
}

通过block的参数进行传递，同样可以解决循环引用，但是这样做的意义不大，因为block在执行的地方，一定是需要获取到self的，如果已经获取到self了，就可以直接对self操作了，再使用block有点多余。应用并不多，只做了解。

Block中对象的引用计数

来道经典的面试题：

- (void)func3 {NSObject *o = [[NSObject alloc] init];NSLog(@"CFGetRetainCount print start");NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)o));//1void(^strongBlock)(void) = ^ {NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)o));};strongBlock();//3  在栈区引用一次，在堆区又引用一次void(^ __weak weakBlock)(void) = ^{NSLog(@"%ld", CFGetRetainCount((__bridge CFTypeRef)o));};weakBlock();// 4栈区引用一次void(^copyBlock)(void) = [strongBlock copy];copyBlock();// 4 本来就在栈上不用+1。void(^copyBlock1)(void) = [weakBlock copy];copyBlock1();// 5NSLog(@"CFGetRetainCount print end");
}

Block Copy

在Block源码中，有关于BlockCopy的源码：

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// 拷贝 block，
// 如果原来就在堆上，就将引用计数加 1;
// 如果原来在栈上，会拷贝到堆上，引用计数初始化为 1，并且会调用 copy helper 方法（如果存在的话）；
// 如果 block 在全局区，不用加引用计数，也不用拷贝，直接返回 block 本身
// 参数 arg 就是 Block_layout 对象，
// 返回值是拷贝后的 block 的地址
// 运行？stack -》malloc
void *_Block_copy(const void *arg) {struct Block_layout *aBlock;// 如果 arg 为 NULL，直接返回 NULLif (!arg) return NULL;// The following would be better done as a switch statement// 强转为 Block_layout 类型aBlock = (struct Block_layout *)arg;const char *signature = _Block_descriptor_3(aBlock)->signature;// 如果现在已经在堆上if (aBlock->flags & BLOCK_NEEDS_FREE) {// latches on high// 就只将引用计数加 1latching_incr_int(&aBlock->flags);return aBlock;}// 如果 block 在全局区，不用加引用计数，也不用拷贝，直接返回 block 本身else if (aBlock->flags & BLOCK_IS_GLOBAL) {return aBlock;}else {// Its a stack block.  Make a copy.// block 现在在栈上，现在需要将其拷贝到堆上// 在堆上重新开辟一块和 aBlock 相同大小的内存struct Block_layout *result =(struct Block_layout *)malloc(aBlock->descriptor->size);// 开辟失败，返回 NULLif (!result) return NULL;// 将 aBlock 内存上的数据全部复制新开辟的 result 上memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
#if __has_feature(ptrauth_calls)// Resign the invoke pointer as it uses address authentication.result->invoke = aBlock->invoke;
#endif// reset refcount// 将 flags 中的 BLOCK_REFCOUNT_MASK 和 BLOCK_DEALLOCATING 部分的位全部清为 0result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed// 将 result 标记位在堆上，需要手动释放；并且引用计数初始化为 1result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1// copy 方法中会调用做拷贝成员变量的工作_Block_call_copy_helper(result, aBlock);// Set isa last so memory analysis tools see a fully-initialized object.// isa 指向 _NSConcreteMallocBlockresult->isa = _NSConcreteMallocBlock;return result;}
}

• copy的调用时机，有强指针第一次指向的时候，会调用一次copy。而这次copy，会把栈区的Block拷贝到堆区。在平时使用[block copy]的时候，也会调用。
• copy的时候根据Block的类型采取了不同的操作，如果是堆block，只进行引用计数+1，相当于浅拷贝，如果是全局block，直接返回，相当于不拷贝，如果是栈block，是重新开辟新的内存并创建，并且isa指向_NSConcreteMallocBlock，设置类型为堆block，然后返回。

在_Block_copy源码中，从栈区copy到堆区的过程中，_Block_call_copy_helper(result, aBlock)的调用时为了复制栈区的Block里面的成员变量，给堆区的Block。

// 调用 block 的 copy helper 方法，即 Block_descriptor_2 中的 copy 方法
static void _Block_call_copy_helper(void *result, struct Block_layout *aBlock)
{// 取得 block 中的 Block_descriptor_2struct Block_descriptor_2 *desc = _Block_descriptor_2(aBlock);// 如果没有 Block_descriptor_2，就直接返回if (!desc) return;// 调用 desc 中的 copy 方法，copy 方法中会调用 _Block_object_assign 函数(*desc->copy)(result, aBlock); // do fixup
}

其中最最要的代码时找到了一个copy方法然后调用。而这个copy方法是在desc中。需要理解这些代码，需要借助clang重写的c++代码。

在重写的代码中可以看到__object_c_origin_block_hello_block_impl_0的构造函数的调用：

__object_c_origin_block_hello_block_desc_0_DATA = {0,sizeof(struct __object_c_origin_block_hello_block_impl_0),__object_c_origin_block_hello_block_copy_0,__object_c_origin_block_hello_block_dispose_0
};

其实这里根据变量名称，就能猜个大概，__object_c_origin_block_hello_block_desc_0_DATA就是源码中的desc，而__object_c_origin_block_hello_block_copy_0即为(*desc->copy)方法。所以我们要看其中拷贝成员变量的过程，需要关注__object_c_origin_block_hello_block_copy_0的实现。

static void __object_c_origin_block_hello_block_copy_0(struct __object_c_origin_block_hello_block_impl_0*dst,struct __object_c_origin_block_hello_block_impl_0*src)
{_Block_object_assign((void*)&dst->obj, (void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}

这里是因为重写前的objcet-c代码里面的block捕获了1个局部变量，只用copy一个成员变量所以只会有一句，如果捕获多个局部变量，就会有多句。例如：

static void __object_c_origin_block_hello_block_copy_0(struct __object_c_origin_block_hello_block_impl_0*dst, struct __object_c_origin_block_hello_block_impl_0*src)
{_Block_object_assign((void*)&dst->obj, (void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);_Block_object_assign((void*)&dst->obj1, (void*)src->obj1, 3/*BLOCK_FIELD_IS_OBJECT*/);}

其内部其实是调用了_Block_object_assign方法，在源码中也可以找到_Block_object_assign的实现：

/*******************************************************block 可以引用 4 种不同的类型的对象，当 block 被拷贝到堆上时，需要 help，即帮助拷贝一些东西。1）基于 C++ 栈的对象2）Objective-C 对象3）其他 Block4）被 __block 修饰的变量block 的 helper 函数是编译器合成的（比如编译器写的 __main_block_copy_1() 函数），它们被用在 _Block_copy() 函数和 _Block_release() 函数中。copy helper 对基于 C++ 栈的对象调用调用 C++ 常拷贝构造函数，对其他三种对象调用 _Block_object_assign 函数。 dispose helper 对基于 C++ 栈的对象调用析构函数，对其他的三种调用 _Block_object_dispose 函数。_Block_object_assign 和 _Block_object_dispose 函数的第三个参数 flags 有可能是：1）BLOCK_FIELD_IS_OBJECT(3) 表示是一个对象2）BLOCK_FIELD_IS_BLOCK(7) 表示是一个 block3）BLOCK_FIELD_IS_BYREF(8) 表示是一个 byref，一个被 __block 修饰的变量；如果 __block 变量还被 __weak 修饰，则还会加上 BLOCK_FIELD_IS_WEAK(16)所以 block 的 copy/dispose helper 只会传入四种值：3，7，8，24上述的4种类型的对象都会由编译器合成 copy/dispose helper 函数，和 block 的 helper 函数类似，byref 的 copy helper 将会调用 C++ 的拷贝构造函数（不是常拷贝构造），dispose helper 则会调用析构函数。还一样的是，helpers 将会一样调用进两个支持函数中，对于对象和 block，参数值是一样的，都另外附带上 BLOCK_BYREF_CALLER (128) bit 的信息。#疑问：调用的这两个函数是啥？BLOCK_BYREF_CALLER 里究竟存的是什么？？所以 __block copy/dispose helper 函数生成 flag 的值为：对象是 3，block 是 7，带 __weak 的是 16，并且一直有 128，有下面这么几种组合：__block id                   128+3       (0x83)__block (^Block)             128+7       (0x87)__weak __block id            128+3+16    (0x93)__weak __block (^Block)      128+7+16    (0x97)********************************************************///
// When Blocks or Block_byrefs hold objects then their copy routine helpers use this entry point
// to do the assignment.
// 当 block 和 byref 要持有对象时，它们的 copy helper 函数会调用这个函数来完成 assignment，
// 参数 destAddr 其实是一个二级指针，指向真正的目标指针
void _Block_object_assign(void *destArg, const void *object, const int flags) {const void **dest = (const void **)destArg;switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {case BLOCK_FIELD_IS_OBJECT:/*******id object = ...;[^{ object; } copy];********/// 默认什么都不干，但在 _Block_use_RR() 中会被 Objc runtime 或者 CoreFoundation 设置 retain 函数，// 其中，可能会与 runtime 建立联系，操作对象的引用计数什么的_Block_retain_object(object);// 使 dest 指向的目标指针指向 object*dest = object;break;case BLOCK_FIELD_IS_BLOCK:/*******void (^object)(void) = ...;[^{ object; } copy];********/// 使 dest 指向的拷贝到堆上object*dest = _Block_copy(object);break;case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:case BLOCK_FIELD_IS_BYREF:/*******// copy the onstack __block container to the heap// Note this __weak is old GC-weak/MRC-unretained.// ARC-style __weak is handled by the copy helper directly.__block ... x;__weak __block ... x;[^{ x; } copy];********/// 使 dest 指向的拷贝到堆上的byref*dest = _Block_byref_copy(object);break;case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:/*******// copy the actual field held in the __block container// Note this is MRC unretained __block only. // ARC retained __block is handled by the copy helper directly.__block id object;__block void (^object)(void);[^{ object; } copy];********/// 使 dest 指向的目标指针指向 object*dest = object;break;case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:/*******// copy the actual field held in the __block container// Note this __weak is old GC-weak/MRC-unretained.// ARC-style __weak is handled by the copy helper directly.__weak __block id object;__weak __block void (^object)(void);[^{ object; } copy];********/// 使 dest 指向的目标指针指向 object*dest = object;break;default:break;}
}

这里是对成员变量的类型进行了分类，如果是对象类型的，直接将对象的增加对象的引用计数，如果是Block类型，会对该Block也进行一次_Block_copy操作，如果是__block修饰的，会调用_Block_byref_copy。_Block_byref_copy的解析在下面👇。

__block

对于__block修饰的对象，底层会将其多封装一层。

struct __Block_byref_obj_0 {void *__isa;
__Block_byref_obj_0 *__forwarding;int __flags;int __size;void (*__Block_byref_id_object_copy)(void*, void*);void (*__Block_byref_id_object_dispose)(void*);NSObject *obj;
};

在对block内部操作，其根本是操作他的__forwarding->obj操作:

    NSLog((NSString *)&__NSConstantStringImpl__var_folders_qz_4pv2xnmd3g137rwtb0fpj2rr0000gn_T_OSBlockOriginFile_ce67cf_mi_1,(obj->__forwarding->obj));(obj->__forwarding->obj) = __null;

在Block Copy的时候，__block修饰的对象或类型在拷贝的过程中会调用_Block_byref_copy进行拷贝。

// 1. 如果 byref 原来在堆上，就将其拷贝到堆上，拷贝的包括 Block_byref、Block_byref_2、Block_byref_3，
//    被 __weak 修饰的 byref 会被修改 isa 为 _NSConcreteWeakBlockVariable，
//    原来 byref 的 forwarding 也会指向堆上的 byref;
// 2. 如果 byref 已经在堆上，就只增加一个引用计数。
// 参数 dest是一个二级指针，指向了目标指针，最终，目标指针会指向堆上的 byref
static struct Block_byref *_Block_byref_copy(const void *arg) {// arg 强转为 Block_byref * 类型struct Block_byref *src = (struct Block_byref *)arg;// 引用计数等于 0if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {// src points to stack// 为新的 byref 在堆中分配内存struct Block_byref *copy = (struct Block_byref *)malloc(src->size);copy->isa = NULL;// byref value 4 is logical refcount of 2: one for caller, one for stack// 新 byref 的 flags 中标记了它是在堆上，且引用计数为 2。// 为什么是 2 呢？注释说的是 non-GC one for caller, one for stack// one for caller 很好理解，那 one for stack 是为什么呢？// 看下面的代码中有一行 src->forwarding = copy。src 的 forwarding 也指向了 copy，相当于引用了 copycopy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;// 堆上 byref 的 forwarding 指向自己copy->forwarding = copy; // patch heap copy to point to itself// 原来栈上的 byref 的 forwarding 现在也指向堆上的 byrefsrc->forwarding = copy;  // patch stack to point to heap copy// 拷贝 sizecopy->size = src->size;// 如果 src 有 copy/dispose helperif (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {// Trust copy helper to copy everything of interest// If more than one field shows up in a byref block this is wrong XXX// 取得 src 和 copy 的 Block_byref_2struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);// copy 的 copy/dispose helper 也与 src 保持一致// 因为是函数指针，估计也不是在栈上，所以不用担心被销毁copy2->byref_keep = src2->byref_keep;copy2->byref_destroy = src2->byref_destroy;// 如果 src 有扩展布局，也拷贝扩展布局if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);// 没有将 layout 字符串拷贝到堆上，是因为它是 const 常量，不在栈上copy3->layout = src3->layout;}// 调用 copy helper，因为 src 和 copy 的 copy helper 是一样的，所以用谁的都行，调用的都是同一个函数(*src2->byref_keep)(copy, src);}else {// Bitwise copy.// This copy includes Block_byref_3, if any.// 如果 src 没有 copy/dispose helper// 将 Block_byref 后面的数据都拷贝到 copy 中，一定包括 Block_byref_3memmove(copy+1, src+1, src->size - sizeof(*src));}}// already copied to heap// src 已经在堆上，就只将引用计数加 1else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {latching_incr_int(&src->forwarding->flags);}return src->forwarding;
}

__block和Block类似，如果在栈区，会重新malloc一份，进行深拷贝操作，但这两个forwarding都会指向堆区的，如果已经在堆区，只会将其引用计数+1。

参考博客：

iOS八股文（十六）关于Block，你在第几层？