【4858.com】iOS中block的大循环引用难点,循环引用
不会促成循环引用的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》中的图片
图中,“必要照明的食指”即对应我们要说的引用计数值。
- 率先个体进入办公,“须求照明的食指”加一,计数值从0变为一,因而要求开灯;
- 从此现在每当有人进入办公,“必要照明的总人口”就加一。如计数值从一产生贰;
- 每当有人下班离开办公室,“需求照明的总人口”加减一如计数值从二形成一;
- 末尾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实行试行以前早已被保释了,该办法也对事情未有何帮忙。
相关文章
- 静态类和类成员,静态类类成员
- Python中避免sql注入的点子详解,Python中预防sql注入的主意详解
- 深远精通is_callable和method_exists,Javascript权威指南
- 【4858.com】设置pydev后不出新,PyDev环境搭建
- 【4858.com】dede首页调用栏目内容_,dede后台栏目页加内容
- webapi二参数绑定,二参数绑定方法
- 【4858.com】PHP面向对象的进阶学习,面向对象
- 崭新管理工科具AppCmd,配置IIS7显示详细错误新闻
- 【4858.com】字典的应用
- 应用Python中的greenlet包达成产出编制程序的入门教程,轻量级并发程序