最近都在折腾 Sagit 架框的内存释放的问题，所以对这一块有些心得。

对于新手，学到的文章都在教你用：typeof(self) __weak weakSelf = self。

对于老手，可能早习惯了到处了WeakSelf了。

这次，就来学学，如何不用WeakSelf。

这里先设计一个TableBlock类：

  1. @interface BlockTable : NSObject
  3. typedef void (^AddCellBlock)();
  4. @property (nonatomic,copy)AddCellBlock addCell;@end

先这么简单，一个BlockTable只有一个block属性，然后输出一段释放的日志。

  1. -(void)dealloc
  2. {
  3.     NSLog(@"Table relase");//relase为错误字，为了和下图保持一致的错别字，这里就不改了。
  4. }

接着，随意找一个地方写写代码：来new了一个BlockTable，并打印一下信息：

这时候它的引用数是1，并且出了Table relase 。

接着给addCell属性赋一个值，并运行：

一个空的事件，里面并没有引用到table，所以引用数还是1。

在block引用table，让它产生循环引用，并运行：

一个属性赋值，为什么增强两个引用计数？

接下来，把属性设置为nil，运行看看：

设置为nil，还有2?

也正常释放了？

为了证实自己对这个看起来就很明显的猜想：重写addCell的setter方法，不进行任何保存：

  1. @implementation BlockTable
  2. -(void)setAddCell:(AddCellBlock)addCell
  3. {
  4.     
  5. }

同时去掉置为nil的代码：再运行看看：

计数器仍为2，而且也释放了。

经过思考，出来了以下的结论：

  1. 1：块的定义本身，就会造成1次引用，不过这次引用，在块离开所在的函数时，释放时，抵消掉引用数。
  3. 2：存档块的时候，会造成1次引用，而这个引用，是内存无法释放的原因。
  1. 只要block的代码只执行1次的，都可以任性的self或其它强引用。
  3. 事实上，我们写的代码，很多block的确只执行一次，不管是传的时候就执行，还是传完之后过段时间回调再执行。
  5. 认定只要执行1次的，就不需要WeakSelf，除非第三方框架的设计者造孽留坑,忘了在存档block执行后补上block=nil这一刀。

继续发挥想象力，既然存的时候，会增加一次引用，辣么，让它不增加引用不就好了：

  1. @implementation BlockTable
  2. -(void)setAddCell:(AddCellBlock)addCell
  3. {
  4.     __weak AddCellBlock addCellWeak=addCell;
  5.     _addCell=addCellWeak;
  6. }

我们先给这个block定义一个弱引用，然后再赋值给_addCell，运行看看：

哇草，成功了！计数器为2，正常释放了，看来自己的想象力，还是可以的！！

接下来，我们补充完善一下代码，增加一个reloadData方法，方法里调用事件。

完整的代码如下：

  1. @interface BlockTable : NSObject
  3. typedef void (^AddCellBlock)();
  4. @property (nonatomic,copy)AddCellBlock addCell;
  6. -(void)reloadData;
  7. @end
  8.  
  9. @implementation BlockTable
  10. -(void)setAddCell:(AddCellBlock)addCell
  11. {
  12.     __weak AddCellBlock addCellWeak=addCell;
  13.     _addCell=addCellWeak;
  14. }
  15. -(void)reloadData
  16. {
  17.     if(self.addCell)
  18.     {
  19.         self.addCell();
    　　　　 self.addCell();//没事来两次，模拟table多次循环清加cell
  20.     }
  21. }
  22. -(void)dealloc
  23. {
  24.     NSLog(@"Table relase");
  25. }
  26. @end

修改一下增加日志输出，现在再执行一下看看：

一切看起来都相当完美，不需要引入第三，需要多次使用的，只是在存的时候，存个弱引用，就搞定了。

  1. 块的定义，和使用的场景，必须在同一个函数。
  3. 说白了就是块离开函数体就会消亡，所以要用要赶紧，且用且珍惜。

正常一个Table写完代码reloadData后，数据出来了。

而这个重新调用reloadData的地方，可能跟block不在同一个函数，比如代码像这样：

  1. -(void)start
  2. {
  3.     BlockTable *table=[BlockTable new];
  4.     self.table=table;//搞到全局变量中
  5.     table.addCell = ^{
  6.         __weak typeof(table) this=table;
  7.         NSLog(@"addCell call");
  8.     };
  9.     [table reloadData];
  10.     NSLog(@"table retain = %ld",CFGetRetainCount((__bridge CFTypeRef)(table)));
  11. }
  12. -(void)reflesh
  13. {
  14.     [self.table reloadData];
  15. }

给外面的类定义了一个table属性，然后调用完start后再调用reflesh，运行，会怎样呢？

出现了IOS上最可怕的EXC_BAD_ACCESS 野指针错误。

对于block离开函数后，消亡了容易理解，只是这里：

这什么是直接抛异常？哥不是作了判断了么？

让我们换种代码写法：

另外从上图看：_addCell还是有值的。

  1. 为什么if(self.addCell)判断就直接死，if(_addCell)却没死呢？
  3. 正常self.addCell正常不是也return _addCell么？
  5. 这个问题，留给让你们思考了。

 

最可怕的，还是下面的这段话：

OK，继续发挥想象力，看看怎么避开野指针，同时还是实现上述的效果：

1：把block属性从copy改成weak

  1. @property (nonatomic,weak)AddCellBlock addCell;

2：赋值代码手工copy：

  1. -(void)setAddCell:(AddCellBlock)addCell
  2. {
  3.     addCell=[addCell copy];
  4.     _addCell=addCell;
  5.     //_addCell=[addCell copy];这样简写是不行的，不明白为虾米呢
  6.     
  7.     //    原来是这样写的：
  8.     //   __weak AddCellBlock addCellWeak=addCell;
  9.     //    _addCell=addCellWeak ;
  10. }

再次运行，神奇的事情发生了：

流程还是很顺，不会有野批针异常，Table也释放了。

唯一的遗憾，就是跳出函数后，block不能再复用了：

对于默认传进来的block（有三种形态：全局、栈、堆）

  1. 全局 copy 还是全局
  3. 堆 copy 还是堆
  5. 栈 copy 变成堆

说白了，copy只对类型是栈是才有效。

这是因为：栈的block，在执行完后出括号后，直接是销毁对象。

如果有弱引用过去，会造成野指针。

而其它两种类型，销毁时，会将指针指向一个空指针。

  1. addCell=[addCell copy] 和默认copy的属性 _addCell=addCell 也是执行了copy操作。

执行后，addCell的类型就变成堆形态，这样销毁的时候，是空指针。

  1. 空指针：指向一个：人为创造的一个指针，它的名字叫空，有座空房子，里面什么也没有。
  3. 野指针：就是指向的都不知哪去了，连空房子都木有。

弱引用的坏处，就是block出了函数，就不再可用这个block了。

那还能怎么办呢？没事，我还有想象力！！！！！

如果block可以重建呢？

比如：

  1. 1：将block转成字符串存档，适当时机还原回来重新赋值
  3. 2：将block序列化保存，适当时机还原回来？
  5. 3：runtime读取block的__FuncPtr，存档再动态创建？

伪代码大体如下：

  1. -(void)setAddCell:(AddCellBlock)addCell
  2. {
  3.     addCell=[addCell copy];
  4.     _addCell=addCell;
  5.     
  6.     //_addCell=[addCell copy];这样简写是不行的，不明白为虾米呢
  7.     
  8.     //    原来是这样写的：
  9.     //   __weak AddCellBlock addCellWeak=addCell;
  10.     //    _addCell=addCellWeak ;
  11.     
  12.     //存档block的字符串
  13. }
  14. -(void)reloadData
  15. {
  16.     if(!_addCell)
  17.     {
  18.         //从存档的block字符串还原block
  19.         //_addCell=还原block
  20.     }
  21.     if(_addCell)
  22.     {
  23.         _addCell();
  24.         _addCell();
  25.     }
  26. }

那么就剩下两个问题？

  1. 1：怎么把block存档？
  3. 2：怎么将存档数据还原成block。

对搞C#的来说，这些都家常便饭，oc这块还不熟，有路过的朋友可顺路给支支招！！

不过这个引入第三者，只是一个时机切入点，在这个时机触发的时候，将其中的一方的引用设置为nil。

像Sagit框架的布局方面的时机，就选在导航回退等事件中处理。

不过这里需要一个小技巧：

在存档block时，不一定要存在当前对象，也可以用一个统一的全局block管理起来。

这样在业务处理时，根据业务情况，从全局block里来移除某些block即可。

具体取决于业务，所以这个就不展开了。

相信，一路看下，看懂了，后续的情况，基本上已经用不上WeakSelf这东西了，因为像一个block，其生命周期必须和持有者保持一致的，还是挺少的。

而这种少的情况，如果第10步解决了，基本就全都解决了，解决不了，还有11。

相信读完此文，如果能完全理解，你就再也看不到block前WeakSelf这种，WeakSelf也没有存在必要了。

最后，欢迎大伙关注IT连创业，虽然最近我都在折腾IOS，哈哈。

不过IOS基础还是要打劳，后续产品改进起来才有质的飞跃。

版权声明：本文为cyq1162原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/cyq1162/p/8235768.html