iOC中block下的__block、__Strong、__weak

Posted 2023-04-04

参考技术A

两个对象相互持有，这样就会造成循环引用，如下图所示

图中，对象A持有对象B，对象B持有对象A，相互持有，最终导致两个对象都不能释放。
即

最普通的情况，由于block会对block中的对象进行持有操作, 就相当于持有了其中的对象 ，而如果此时block中的对象又持有了该block，则会造成循环引用。如下：

调用以上三句均会造成循环引用，因为不管是通过 self.blockString 还是 _blockString ，或是函数调用 [self doSomething] ， 因为只要 block中用到了对象的属性或者函数，block就会持有该对象而不是该对象中的某个属性或者函数。

当有someObj持有self对象，此时的关系图如下。

当someObj对象release self对象时，self和myblock相互引用，retainCount都为1，造成循环引用

解决：

使用 __weak 修饰self，使其在block中不被持有，打破循环引用。开始状态如下

当someObj对象释放self对象时，Self的retainCount为0，走dealloc，释放myBlock对象，使其retainCount也为0。

其实以上循环引用的情况很容易发现，因为此时Xcode就会报警告。而发生在多个对象间的时候，Xcode就检测不出来了，这往往就容易被忽略。

解决方法：

将objA对象weak，使其不在block中被持有

注：以上使用 __weak 打破循环的方法只在ARC下才有效，在MRC下应该使用 __block

或者，在block执行完后，将block置nil，这样也可以打破循环引用

这样做的缺点是，block只会执行一次，因为block被置nil了，要再次使用的话，需要重新赋值。

在开发工程中，发现一些同学并没有完全理解循环引用，以为只要有block的地方就会要用__weak来修饰对象，这样完全没有必要，以下几种block是不会造成循环引用的。

大部分GCD方法

因为self并没有对GCD的block进行持有，没有形成循环引用。目前我还没碰到使用GCD导致循环引用的场景，如果某种场景self对GCD的block进行了持有，则才有可能造成循环引用。

block并不是属性值，而是临时变量

这里因为block只是一个临时变量，self并没有对其持有，所以没有造成循环引用

看下面例子，有这种情况，如果不只是ClassA持有了myBlock，ClassB也持有了myBlock。

当ClassA被someObj对象释放后

此时，ClassA对象已经被释放，而myBlock还是被ClassB持有，没有释放；如果myBlock这个时被调度，而此时ClassA已经被释放，此时访问的ClassA将是一个nil对象（使用 __weak 修饰，对象释放时会置为nil），而引发错误。

另一个常见错误使用是，开发者担心循环引用错误（如上所述不会出现循环引用的情况），使用 __weak 。比如

此时导致doSomething直接无法执行，因为 block作为参数传给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象 ,因为dispatch_async并不知道block中对象会在什么时候被释放，为了确保系统调度执行block中的任务时其对象没有被意外释放掉， dispatch_async必须自己retain一次对象（即self），任务完成后再release对象（即self） 。但这里使用 __weak ，使dispatch_async没有增加self的引用计数，这使得在系统在调度执行block之前，self可能已被销毁，但系统并不知道这个情况，导致block执行时访问已经被释放的self，而达不到预期的结果。

理解这点很重要，这是许多使用 __weak,__stong 的由来，实际的过程原理与block实现有关，下文会补充，这里先记住这点。

注：如果是在MRC模式下，使用 __block 修饰self,则此时block访问被释放的self，则会导致crash。 如下：

运行结果

解决方法：

对于这种场景，就不应该使用 __weak 来修饰对象，让dispatch_after对self进行持有，保证block执行时self还未被释放。

还有一种场景，在block执行开始时self对象还未被释放，而执行过程中，self被释放了，此时访问self时，就会发生错误。

对于这种场景，应该在block中对 对象使用 __strong 修饰，使得在block期间对 对象持有，block执行结束后，解除其持有。这也就是为什么许多使用block的地方内外要

注：此方法只能保证在block执行期间对象不被释放，如果对象在block执行执行之前已经被释放了，该方法也无效。

讲到这里不得不提及一下 __block 。承接前面的例子，均是在block中使用其他对象的方法。实际应用中会有在block使用变量，或其他对象属性的情况。如下：

亦或是

无论是在block中修改外部变量、或是对其他熟悉的操作。因为block在其他线程中执行，取值时是进行copy操作，如果是有self等引用则不会有问题，如果是外部变量或临时声明的对象，在block做处理操作时则要考虑，是否希望改变原来的值。这里的__block起到了原来c语言中&取地址，传递地址的作用。

这里的作用机理和block的机理有关，block本身的核心逻辑是C中的匿名方法，因为C语言中方法是可以作为属性来传递的，OC中将block需要使用的方法快作为匿名方法的熟悉，封装在一个结构体中。而这句__block则是将对于需要传递内存的属性/对象一同封装在这个结构体中。

不过我个人觉得，这种临时变量需要在block中进行处理，然后希望同时影响外部的需求。我认为在业务需求上是很少用到的，大家想避免还是很容易。

1.要注意block本身持有情况，及block内部的持有情况，尤其是类似“ block myBlock”等已经在类内部全局声明持有的block
2.block本身并不是属性值，而是临时变量，故不要一味的在weak中使用weak
3.在block外部声明的临时变量，需要在block内部继续使用时，要用__strong声明，来防止在进入block前，已经被释放掉了。
4.如果有临时变量/对象需要放到block中处理，且希望是Strong传递而非Copy传递则用 __block 修饰

小声bb：讲了这么多，其实很简单，遇到block，先看block是否全局引用了，如果全局引用了，则其内部的self等必然要weak处理。二要看内部是否使用了临时变量/对象的方法，如果使用了则要考虑是否需要使用strong防止对象过程释放。__block就是给临时变量，修改隐性的copy为strong。

本篇中许多内容引用自
https://www.jianshu.com/p/492be28d63c4
感谢🙏作者@HK_Hank

block原理部分大家感兴趣可以看
https://segmentfault.com/a/1190000018779727
https://www.jianshu.com/p/221d0778dcaa
https://www.jianshu.com/p/00a7ee0177ea

附上项目中常用宏，供大家参考使用

使用大致如下

__block变量存储域

将Block赋值给strong 类型的block变量，或者赋值给strong 修饰的对象类型中的block成员变量时，block会从栈复制到堆上。那__block变量会有什么变化呢？

其实，当block 被从栈复制到堆上时，block中使用到的变量也会从栈赋值到堆上。

当block被从栈复制到堆前后，__block变量存储域变化如下：

• 1.block在栈上时，__block的存储域是栈，__block变量被栈上的block持有。
• 2.block被复制到堆上时，__block变量的存储域是堆，__block变量被堆上的block持有。
  
  如果多个Block使用同一个__block变量时，一开始多个Block都会配置在栈上，所以__block变量也会配置在栈上。在任何一个Block从栈复制到堆上时，__block变量也会一并从栈复制到堆并被堆上的Block所持有。当剩下的Block从栈复制到堆时，被复制的Block持有__block变量，并增加__block变量的引用计数。

而如果配置在堆上的Block被废弃，那么它所使用的__block变量也会被释放。

从这里可以看出__block变量的管理，与Objective-C的引用计数内存管理方式很相似。使用__block变量的Block，持有__block变量。如果Block被废弃，它所持有的__block变量也会被释放。

这里回顾一下，__block变量内部的__forwarding成员变量作用？

因为__block变量从栈复制到堆，所以在某一个时刻会有两个__block变量，如果将栈上的__forwarding指向堆上的__block变量，就可以保证不管你访问的是栈上的__block变量，还是堆上的__block变量，实际上访问的都是堆上的__block变量。

这样，写法是一致的，而且不管栈上的__block变量是否被释放，都能通过变量的指针地址正确的访问到堆上的__block变量。这样的设计真是非常完美。

当block 中使用__block变量时，__main_block_desc_0结构体内部会多出两个成员变量copy 和 dispose，这两个成员变量是函数指针类型，里面分别存储着两个静态函数__main_block_copy_0 和 __main_block_dispose_0。

enum  
/* See function implementation for a more complete description of these fields and combinations */ 
// 是一个对象 
BLOCK_FIELD_IS_OBJECT = 3, /* id, NSObject, attribute((NSObject)), block, … */ 
// 是一个block 
BLOCK_FIELD_IS_BLOCK = 7, /* a block variable */ 
// 被__block修饰的变量 
BLOCK_FIELD_IS_BYREF = 8, /* the on stack structure holding the __block variable */ 
// 被__weak修饰的变量，只能被辅助copy函数使用 
BLOCK_FIELD_IS_WEAK = 16, /* declared __weak, only used in byref copy helpers */ 
// block辅助函数调用（告诉内部实现不要进行retain或者copy） 
BLOCK_BYREF_CALLER = 128 /* called from __block (byref) copy/dispose support routines. */ 
;

__main_block_copy_0 函数是将block内使用的__block变量，赋值给目标Block用结构体成员变量中，如果是对象类型变量，则持有它。

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) 
    // 这里如果使用多个__block变量，则会在该函数中依次调用_Block_object_assign
    _Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
    _Block_object_assign((void*)&dst->name, (void*)src->name, 3/*BLOCK_FIELD_IS_OBJECT*/);

_Block_object_assign 函数当复制的是对象类型变量时，相当于retain实例方法，将对象类型变量赋值在__main_byref_name_1这样的结构体变量的成员变量中。

__main_block_dispose_0函数内部使用_Block_object_dispose函数，来释放赋值在Block结构体中的成员变量。

static void __main_block_dispose_0(struct __main_block_impl_0*src) 
    _Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
    _Block_object_dispose((void*)src->name, 3/*BLOCK_FIELD_IS_OBJECT*/);

_Block_object_dispose函数中如果传的是对象，则相当于release实例方法的函数，如果是非对象，猜测就是普通的释放变量了。

在Clang 转换出来的C++代码中没有看到调用__main_block_copy_0 和 __main_block_dispose_0的地方，据说是在运行时将Block从栈复制到堆时以及堆上的Block被废弃时会调用这些函数。（这个目前还无法确认）

调用copy函数和dispose函数的时机

函数	调用时机
copy函数	栈上的Block复制到堆时
dispose函数	堆上的Block被释放时

在哪些场景下栈上的Block会复制到堆上呢？

• 1.当调用Block的copy实例方法时
• 2.当Block作为函数返回值返回时
• 3.将Block赋值给附有__strong修饰符的block变量时
• 4.将Block赋值给附有__strong修饰符的对象中的block成员变量时
• 5.在方法名中含有usingBlock的Cocoa框架中的方法中
• 6.在GCD的API中传递Block时

在这些场景下，block就会被从栈上复制到堆上。

为什么在对象中添加block类型的property时，要使用copy修饰符？

其实在ARC下，使用strong ,retain和使用 copy是一样。
我们都知道，在ARC下，使用strong等价于使用retain，而在ARC下对Block执行retain，会被转化为objc_blockRetain。

该函数在runtime中是这样实现的：

//
// The -fobjc-arc flag causes the compiler to issue calls to objc_retain/release/autorelease/retain_block
//

id objc_retainBlock(id x) 
    return (id)_Block_copy(x);

综上所述，在ARC下，对block使用strong等价于使用retain，而对block使用retain，会在运行时调用_Block_copy，所以这跟使用copy是一样的效果。

而将block从栈复制到堆上时，可以防止block或者block中使用的变量被释放。
对block使用copy函数，不管是栈上的、堆上的、全局的block都不会出现问题。所以，我们就统一使用copy来修饰了。