不会促成循环引用的block

在讲block的巡回引用难题从前，大家要求先理解一下iOS的内部存款和储蓄器管理机制和block的基本知识

本文重要介绍APAJEROC下block的循环引用难点，举例表达引起循环引用的情况和相应的消除方案。

总来说之那整个实际就是为着防守循环引用，上边结合网络上各位大牌的解析经典分析分析

大部分GCD方法

1 dispatch_async(dispatch_get_main_queue(), ^{
2     [self doSomething];
3 });

因为self并未对GCD的block举行富有，未有变异巡回引用。近年来自个儿还没遇上使用GCD导致循环引用的景观，纵然某种场景self对GCD的block举办了全部，则才有一点都不小概率引致循环引用。

 

iOS的内存管理机制

在讲block的巡回引用难题此前，大家须要先领悟一下iOS的内部存储器管理机制和block的基本知识

block对于其变量都会形成强引用（retain），对于self也会产生强引用（retain）
，而壹旦self本人对block也是强引用的话，就会形成 强引用
循环，不可能自由——造成内部存款和储蓄器败露
怎样是循环引用：对象A持有对象B，对象B持有对象A，相互持有，最后致使八个目的都无法假释。

block并不是属性值，而是近期变量

 1 - (void)doSomething {
 2     [self testWithBlock:^{
 3         [self test];
 4     }];
 5 }
 6 
 7 - (void)testWithBlock:(void(^)())block {
 8     block();
 9 }
10 
11 - (void)test {
12     NSLog(@"test");
13 }

那里因为block只是二个暂且变量，self并不曾对其颇具，所以未有产生循环引用

 

Objective-C在iOS中不援助GC(垃圾回收)机制，而是使用的引用计数的主意管理内部存款和储蓄器。

iOS的内部存款和储蓄器管理机制

Objective-C在iOS中不帮助GC机制，而是选拔的引用计数的方法管理内部存款和储蓄器。

在引用计数中，每1个对象承担爱惜对象具有引用的计数值。当2个新的引用指向对象时，引用计数器就星罗棋布，当去掉三个引用时，引用计数就递减。当引用计数到零时，该对象就将释放占领的能源。

笔者们由此按键房间的灯为例来�表达引用计数机制。

引用《Pro
Multithreading and Memory Management for iOS and OS X》中的图片

图中，“必要照明的食指”即对应我们要说的引用计数值。

1. 率先个体进入办公，“须求照明的食指”加一，计数值从0变为一，因而要求开灯；
2. 从此现在每当有人进入办公，“必要照明的总人口”就加一。如计数值从一产生贰；
3. 每当有人下班离开办公室，“需求照明的总人口”加减一如计数值从二形成一；
4. 末尾1个人下班离开办公室时，“须要照明的人数”减一。计数值从一形成0，因而需求关灯。

在Objective-C中，”对象“约等于办公的照明设备，”对象的选用条件“相当于进入办公室的人。上班进入办公的人对办公照明设备发出的动作，与Objective-C中的对应关系如下表

对照明设备所做的动作	对Objective-C对象所做的动作
开灯	生成对象
需要照明	持有对象
不需要照明	释放对象
关灯	废弃对象

选拔计数功效计算必要照明的人数，使办公室的照明获得了很好的治本。同样，使用引用计数成效，对象也就能获得很好的军管，那就是Objective-C内部存款和储蓄器管理，如下图所示

引用《Pro
Multithreading and Memory Management for iOS and OS X》中的图片

Objective-C对象方法	说明
alloc/new/copy/mutableCopy	创建对象，引用计数加1
retain	引用计数加1
release	引用计数减1
dealloc	当引用计数为0时调用
[NSArray array]	引用计数不增加，由自动释放池管理
[NSDictionary dictionary]	引用计数不增加，由自动释放池管理

关于机关释放，不是本文的重中之重，那里就不讲了。

Objective-C对象所有权修饰符	说明
__strong	对象默认修饰符，对象强引用，在对象超出作用域时失效。其实就相当于retain操作，超出作用域时执行release操作
__weak	弱引用，不持有对象，对象释放时会将对象置nil。
__unsafe_unretained	弱引用，不持有对象，对象释放时不会将对象置nil。
__autoreleasing	自动释放，由自动释放池管理对象

循环引用场景：
一、block在主函数体用到了self / self.变量 / [self
方法]，意味着：block对self 实行具备操作；
贰、self注解了质量变量block，block用copy来修饰，意味着：self对block举行富有操作，会形成循环引用；
比如下图，今后那样写Xcode间接就会有警告出来告诉您那边貌似retain
cycle了啊！！

block使用对象被提前释放

有那种景观，要是不只是ClassA持有了myBlock，ClassB也富有了myBlock。

当ClassA被someObj对象释放后

那儿，ClassA对象已经被放飞，而myBlock依旧被ClassB持有，未有自由；假使myBlock这么些时被调度，而那时候ClassA已经被假释，此时拜会的ClassA将是二个nil对象（使用__weak修饰，对象释放时会置为nil），而吸引错误。

 

另三个广阔错误选拔是，开拓者忧郁循环引用错误（如上所述不会产出循环引用的景况），使用__weak。比如

1 __weak typeof(self) weakSelf = self;
2 dispatch_async(dispatch_get_main_queue(), ^{
3     [weakSelf doSomething];
4 });

因为将block作为参数传给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象，因为dispatch_async并不知道block中目的会在曾几何时被放飞，为了保障系统调度实行block中的任务时其目的未有被意外释放掉，dispatch_async必须团结retain二遍对象（即self），任务到位后再release对象（即self）。但此间运用__weak，使dispatch_async未有扩张self的引用计数，这使得在系统在调度实施block在此以前，self恐怕已被灭绝，但系统并不知道这些状态，导致block实践时访问已经被放走的self，而达不到预期的结果。

 

引用计数(Reference Count)

block的基本知识

block的基本知识那里就不细说了，能够看看小编的稿子说说Objective-C中的block

注：固然是在MLANDC情势下，使用__block修饰self,则此时block访问被放出的self，则会招致crash。 

这场景下的代码

 1 // ClassA.m
 2 - (void)test {
 3     __weak MyClass* weakSelf = self;
 4     double delayInSeconds = 10.0f;
 5     dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
 6     dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
 7         NSLog(@"%@", weakSelf);
 8     });
 9 }
10 
11 // ClassB.m
12 - (void)doSomething {
13     NSLog(@"do something");
14     ClassA *objA = [[ClassA alloc] init];
15     [objA test];
16 }

运作结果

[5988:435396] do something
[5988:435396] self:(null)

缓解格局：

对此那种情景，就不该选用__weak来修饰对象，让dispatch_after对self进行富有，有限支撑block试行时self还未被假释。

 

在引用计数中，每2个对象承担爱惜对象具有引用的计数值。当二个新的引用指向对象时，引用计数器就雨后春笋，当去掉一个引用时，引用计数就递减。当引用计数到零时，该对象就将释放占领的财富。

循环引用难点

八个对象相互持有，那样就会变成循环引用，如下图所示

七个对象相互持有

图中，对象A持有对象B，对象B持有对象A，互相持有，最终致使多少个指标都无法自由。

由于block会对block中的对象开始展览富有操作,就一定于具备了里面包车型客车对象，而假如此刻block中的对象又拥有了该block，则会导致循环引用。如下，

typedef void;@property (copy, nonatomic) block myBlock;@property (copy, nonatomic) NSString *blockString;- testBlock { self.myBlock = ^() { //其实注释中的代码，同样会造成循环引用 NSString *localString = self.blockString; //NSString *localString = _blockString; //[self doSomething]; };}

注：以下调用注释掉的代码一样会招致循环引用，因为无论是透过self.blockString还是_blockString，或是函数调用[self doSomething]，因为壹旦
block中用到了指标的品质恐怕函数，block就会具有该目的而不是该指标中的有个别属性大概函数。

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

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

化解办法：

__weak typeof weakSelf = self;self.myBlock = ^() { NSString *localString = weakSelf.blockString;};

使用__weak修饰self，使其在block中不被全数，打破循环引用。先导意况如下

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

实际以上循环引用的地方很轻便觉察，因为那时Xcode就会报警告。而发生在多少个指标间的时候，Xcode就检验不出来了，那频仍就便于被忽略。

//ClassB@interface ClassB : NSObject@property (strong, nonatomic) ClassA *objA;- doSomething;@end //ClassA@property (strong, nonatomic) ClassB *objB;@property (copy, nonatomic) block myBlock;- testBlockRetainCycle { ClassB* objB = [[ClassB alloc] init]; self.myBlock = ^() { [objB doSomething]; }; objB.objA = self;}

不留余地办法：

- testBlockRetainCycle { ClassB* objB = [[ClassB alloc] init]; __weak typeof weakObjB = objB; self.myBlock = ^() { [weakObjB doSomething]; }; objB.objA = self;}

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

注：以上使用__weak打破循环的方法只在A猎豹CS六C下才有效，在M福特ExplorerC下相应运用__block

抑或，在block实践完后，将block置nil，那样也能够打破循环引用

- testBlockRetainCycle { ClassB* objB = [[ClassB alloc] init]; self.myBlock = ^() { [objB doSomething]; }; objA.objA = self; self.myBlock(); self.myBlock = nil;}

如此那般做的欠缺是，block只会实施三次，因为block被置nil了，要双重行使以来，要求再度赋值。

在支付工程中，发现部分同校并不曾完全驾驭循环引用，以为只要有block的地点就会要用__weak来修饰对象，那样完全没要求，以下两种block是不会导致循环引用的。

dispatch_async(dispatch_get_main_queue(), ^{ [self doSomething];});

因为self并从未对GCD的block实行具有，未有变异巡回引用。如今自家还没遭遇使用GCD导致循环引用的光景，尽管某种场景self对GCD的block进行了有着，则才有不小希望引致循环引用。

- doSomething { [self testWithBlock:^{ [self test]; }];}- testWithBlock:)block { block();}- test { NSLog;}

此间因为block只是1个一时半刻变量，self并未有对其具备，所以未有导致循环引用

看上面例子，有那种情状，假诺不只是ClassA持有了myBlock，ClassB也具备了myBlock。

当ClassA被someObj对象释放后

此刻，ClassA对象已经被放走，而myBlock仍然被ClassB持有，未有自由；如若myBlock那么些时被调度，而此时ClassA已经被释放，此时拜会的ClassA将是三个nil对象（使用__weak修饰，对象释放时会置为nil），而引发错误。

另3个广大错误选用是，开辟者忧郁循环引用错误（如上所述不会晤世循环引用的景观），使用__weak。比如

__weak typeof weakSelf = self;dispatch_async(dispatch_get_main_queue(), ^{ [weakSelf doSomething];});

因为将block作为参数字传送给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象，因为dispatch_async并不知道block中目的会在怎样时候被放走，为了保险系统调度试行block中的任务时其目的未有被意外释放掉，dispatch_async必须协调retain3回对象，职务达成后再release对象。但此间运用__weak，使dispatch_async未有扩张self的引用计数，那使得在系统在调度施行block以前，self恐怕已被销毁，但系统并不知道这一个意况，导致block试行时访问已经被假释的self，而达不到预期的结果。

注：假诺是在M奥迪Q5C方式下，使用__block修饰self,则此时block访问被放出的self，则会导致crash。

该现象下的代码

// ClassA.m- test { __weak MyClass* weakSelf = self; double delayInSeconds = 10.0f; dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (delayInSeconds * NSEC_PER_SEC)); dispatch_after(popTime, dispatch_get_main_queue(), ^{ NSLog(@"%@", weakSelf); });}// ClassB.m- doSomething { NSLog(@"do something"); ClassA *objA = [[ClassA alloc] init]; [objA test];}

运作结果

[5988:435396] do something[5988:435396] self:

消除措施：

对于这种景色，就不该利用__weak来修饰对象，让dispatch_after对self实行富有，保险block实行时self还未被放飞。

还有一种境况，在block施行起来时self对象还未被释放，而实践进度中，self被保释了，此时造访self时，就会生出错误。

对此那种景色，应该在block中对 对象使用__strong修饰，使得在block时期对
对象具备，block实施完成后，解除其负有。

- testBlockRetainCycle { ClassA* objA = [[ClassA alloc] init]; __weak typeof weakObjA = objA; self.myBlock = ^() { __strong typeof strongWeakObjA = weakObjA; [strongWeakObjA doSomething]; }; objA.objA = self;}

注：此措施只可以确定保障在block实践时期对象不被放飞，假设指标在block试行实践从前已经被假释了，该办法也对事情没有什么帮助。

循环引用例子

block试行进度中目的被假释

还有壹种处境，在block施行起来时self对象还未被放飞，而实行进度中，self被释放了，此时访问self时，就会发出错误。

对于那种情况，应该在block中对 对象使用__strong修饰，使得在block时期对
对象具备，block推行完成后，解除其抱有。

1 - (void)testBlockRetainCycle {
2     ClassA* objA = [[ClassA alloc] init];
3     __weak typeof(objA) weakObjA = objA;
4     self.myBlock = ^() {
5         __strong typeof(weakObjA) strongWeakObjA = weakObjA;
6         [strongWeakObjA doSomething];
7     };
8     objA.objA = self;
9 }

 

注：此方法只可以确定保障在block试行时期对象不被假释，假使目的在block施行实践此前早已被放出了，该格局也无效。

 

参考资料：block的巡回引用难点

我们经过按键房间的灯为例来�表明引用计数机制。

1旦自身想在block里面改造壹些变量的值恐怕选用一些变量，如下图这样写Xcode直接报错
而且付出了缓解办法提醒出来了
那一点还挺机智的，那么大家使用__block修饰之后，再一次在block里面使用，就不会出标题了，完美。

引用《Pro Multithreading and Memory Management for iOS and OS
X》中的图片

解决

图中，“供给照明的总人口”即对应大家要说的引用计数值。

：

率先民用进来办公室，“需求照明的总人口”加一，计数值从0变为一，由此供给开灯；

尔后每当有人进来办公室，“必要照明的总人口”就加一。如计数值从一变成2；

采用一些变量.png

每当有人下班离开办公室，“需求照明的人口”加减1如计数值从二产生1；

在使用block的地方：
__block typeof(self) bself = self;          // 适用MRC模式，
__block NSString *tempStr = @"abc";
__block int a = 0; //当修饰变量时，表示这个变量值能在block中被修改
__weak typeof(self) weakself = self;     // 适用ARC模式

谈到底1个人下班离开办公时，“须求照明的食指”减一。计数值从一造成0，由此要求关灯。

关于——Block在M科雷傲C和A凯雷德C形式的区别
1）__block在M凯雷德C下有多少个作用
【4858.com】iOS中block的大循环引用难点，循环引用。允许在Block中走访和改变部分变量
禁绝Block对所引用的目的举行隐式retain操作

在Objective-C中，”对象“相当于办公的照明设备，”对象的使用条件“约等于进入办公室的人。上班进入办公的人对办公照明设备发出的动作，与Objective-C中的对应关系如下表

2）__block在A帕杰罗C下唯有叁个意义
同目的在于Block中做客和改换部分变量

对照明设备所做的动作对Objective-C对象所做的动作

何以时候在 block 中不需求运用 weakSelf？？？

开灯生成对象

• 大大多GCD方法,因为self并从未对GCD的block举办富有，未有产生巡回引用。近年来本身还没碰到使用GCD导致循环引用的光景，如若某种场景self对GCD的block举办了有着，则才有望引致循环引用。

急需照明持有对象

dispatch_async(dispatch_get_main_queue(), ^{
[self doSomething];
});

不须求照明释放对象

• 大多数卡通效果,当动画结束时，UIView 会甘休全部那几个 block，block
  对象就会自由掉，从而 block 会释放掉对于 self
  的有所。整个内存引用关系被拔除。

关灯甩掉对象

[UIView animateWithDuration:0.2 animations:^{
self.alpha = 1;
}];

行使计数作用总括须求照明的人头，使办公室的照明获得了很好的管住。一样，使用引用计数功效，对象也就能获得很好的治本，那便是Objective-C内存管理，如下图所示

• block并不是目的的性质 / 变量，而是方法的参数 /
  权且变量,那里因为block只是3个暂且变量，self并从未对其全部，所以未有导致循环引用

.- (void) testWithBlock:(void(^)())block {
block();
}

引用《Pro Multithreading and Memory Management for iOS and OS
X》中的图片

• 再有1种情状，block属于Person对象，在另2个类里面使用的时候从不构成互周旋有，那时候也不需求weakSelf。

• 使用GCD的时候，这么写实际是荒唐的，并不是见到block将要为了以免循环引用而选取weakSelf，像上面那种写法，正是大错特错的：

M奥迪Q5C(马努al Reference Counting)中引起应用计数变化的法子

__weak typeof(self) weakSelf = self;
dispatch_async(dispatch_get_main_queue(), ^{
[weakSelf doSomething];
});

Objective-C对象方法求证

因为将block作为参数字传送给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的对象，因为dispatch_async并不知道block中指标会在如哪天候被放飞，为了确认保证系统调度实施block中的职务时其目的未有被意外释放掉，dispatch_async必须协调retain二回对象（即self），职务成功后再release对象（即self）。但此间运用__weak，使dispatch_async未有扩张self的引用计数，那使得在系统在调度施行block在此之前，self或许已被销毁，但系统并不知道那一个情景，导致block实践时访问已经被放飞的self，而达不到预期的结果。

alloc/new/copy/mutableCopy创立对象，引用计数加一

总结
一 在 Block 内若是需求拜访 self 的方法、变量，建议选取 weakSelf。
二 假如在 Block 内供给频仍 访问 self，则必要接纳 strongSelf。

retain引用计数加1

release引用计数减1

dealloc当引用计数为0时调用

[NSArray array]引用计数不扩张，由机关释放池管理

[NSDictionary dictionary]引用计数不扩大，由机关释放池管理

电动释放池

有关机关释放，不是本文的显要，那里就不讲了。

A奇骏C(Automatic Reference Counting)中内部存款和储蓄器管理

Objective-C对象全数权修饰符说明

__strong对象暗中同意修饰符，对象强引用，在指标超越成效域时失效。其实就一定于retain操作，高出效率域时推行release操作

__weak弱引用，不持有对象，对象释放时会将对象置nil。

__unsafe_unretained弱引用，不持有对象，对象释放时不会将指标置nil。

__autoreleasing自动释放，由活动释放池管理对象

block的基本知识

block的基本知识那里就不细说了。

巡回引用难点

五个对象互相持有，那样就会导致循环引用，如下图所示

七个目的相互持有

图中，对象A持有对象B，对象B持有对象A，相互持有，最终产生多少个指标都不能够释放。

block中循环引用难点

鉴于block会对block中的对象实行具备操作,就也正是具有了内部的对象，而假使那时block中的对象又独具了该block，则会招致循环引用。如下，

typedef void(^block)();

@property (copy, nonatomic) block myBlock;

@property (copy, nonatomic) NSString *blockString;

– (void)testBlock {

self.myBlock = ^() {

//其实注释中的代码，一样会促成循环引用

NSString *localString = self.blockString;

//NSString *localString = _blockString;

//[self doSomething];

};

}

注：以下调用注释掉的代码同样会变成循环引用，因为不论是是通过self.blockString照旧_blockString，或是函数调用[self
doSomething]，因为1旦
block中用到了目的的品质可能函数，block就会持有该对象而不是该指标中的某些属性或许函数。

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

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

焚薮而田办法：

__weak typeof(self) weakSelf = self;

self.myBlock = ^() {

NSString *localString = weakSelf.blockString;

};

使用__weak修饰self，使其在block中不被有着，打破循环引用。开端情形如下

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

其实以上循环引用的情景很轻巧察觉，因为此时Xcode就会报告警察方告。而发生在五个对象间的时候，Xcode就检查评定不出去了，这往往就便于被忽视。

//ClassB

@interface ClassB : NSObject

@property (strong, nonatomic) ClassA *objA;

– (void)doSomething;

@end

//ClassA

@property (strong, nonatomic) ClassB *objB;

@property (copy, nonatomic) block myBlock;

– (void)testBlockRetainCycle {

ClassB* objB = [[ClassB alloc] init];

self.myBlock = ^() {

[objB doSomething];

};

objB.objA = self;

}

解决措施：

– (void)testBlockRetainCycle {

ClassB* objB = [[ClassB alloc] init];

__weak typeof(objB) weakObjB = objB;

self.myBlock = ^() {

[weakObjB doSomething];

};

objB.objA = self;

}

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

注：以上使用__weak打破循环的点子只在APRADOC下才使得，在M劲客C下应当选择__block

只怕，在block施行完后，将block置nil，这样也足以打破循环引用

– (void)testBlockRetainCycle {

ClassB* objB = [[ClassB alloc] init];

self.myBlock = ^() {

[objB doSomething];

};

objA.objA = self;

self.myBlock();

self.myBlock = nil;

}

那般做的欠缺是，block只会实施3次，因为block被置nil了，要重新利用的话，必要再行赋值。

壹些不会导致循环引用的block

在支付工程中，发现存的同校并从未完全知晓循环引用，以为假使有block的地点就会要用__weak来修饰对象，那样完全没须求，以下二种block是不会招致循环引用的。

大部分GCD方法

dispatch_async(dispatch_get_main_queue(), ^{

[self doSomething];

});

因为self并从未对GCD的block进行具备，未有产生巡回引用。近期自个儿还没遇上使用GCD导致循环引用的现象，要是某种场景self对GCD的block进行了装有，则才有不小希望产生循环引用。

block并不是属性值，而是如今变量

– (void)doSomething {

[self testWithBlock:^{

[self test];

}];

}

– (void)testWithBlock:(void(^)())block {

block();

}

– (void)test {

NSLog(@”test”);

}

此处因为block只是2个暂且变量，self并未对其全体，所以并没有变成循环引用

block使用对象被提前放出

看下边例子，有那种意况，假如不只是ClassA持有了myBlock，ClassB也具有了myBlock。

当ClassA被someObj对象释放后

此刻，ClassA对象已经被放出，而myBlock依然被ClassB持有，未有自由；借使myBlock那些时被调度，而那时ClassA已经被释放，此时访问的ClassA将是贰个nil对象（使用__weak修饰，对象释放时会置为nil），而引发错误。

另1个宽广错误使用是，开垦者忧郁循环引用错误（如上所述不会出现循环引用的情景），使用__weak。比如

__weak typeof(self) weakSelf = self;

dispatch_async(dispatch_get_main_queue(), ^{

[weakSelf doSomething];

});

因为将block作为参数字传送给dispatch_async时，系统会将block拷贝到堆上，而且block会持有block中用到的指标，因为dispatch_async并不知道block中指标会在如哪天候被保释，为了保证系统调度推行block中的任务时其指标没有被意外释放掉，dispatch_async必须团结retain2遍对象（即self），职务到位后再release对象（即self）。但此处运用__weak，使dispatch_async未有扩展self的引用计数，那使得在系统在调度实践block在此之前，self或许已被灭绝，但系统并不知道那个情景，导致block试行时访问已经被放飞的self，而达不到预期的结果。

注：要是是在MMuranoC形式下，使用__block修饰self,则此时block访问被释放的self，则会招致crash。

该现象下的代码

// ClassA.m

– (void)test {

__weak MyClass* weakSelf = self;

double delayInSeconds = 10.0f;

dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW,
(int64_t)(delayInSeconds * NSEC_PER_SEC));

dispatch_after(popTime, dispatch_get_main_queue(), ^(void){

NSLog(@”%@”, weakSelf);

});

}

// ClassB.m

– (void)doSomething {

NSLog(@”do something”);

ClassA *objA = [[ClassA alloc] init];

[objA test];

}

运行结果

[5988:435396] do something

[5988:435396] self:(null)

缓解办法：

对于那种情景，就不该利用__weak来修饰对象，让dispatch_after对self实行具备，保险block实行时self还未被假释。

block实践进度中指标被释放

4858.com，再有1种情景，在block实施起来时self对象还未被假释，而举办进程中，self被保释了，此时走访self时，就会生出错误。

对此那种场合，应该在block中对 对象使用__strong修饰，使得在block时期对
对象具备，block施行完结后，解除其颇具。

– (void)testBlockRetainCycle {

ClassA* objA = [[ClassA alloc] init];

__weak typeof(objA) weakObjA = objA;

self.myBlock = ^() {

__strong typeof(weakObjA) strongWeakObjA = weakObjA;

[strongWeakObjA doSomething];

};

objA.objA = self;

}

注：此办法只可以担保在block推行时期对象不被释放，假如目的在block实行试行以前早已被保释了，该办法也对事情未有何帮忙。