iOS中block的大循环引用难点,循环引用

不会导致循环引用的block

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

本文首要介绍A科雷傲C下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机制,而是选取的引用计数的不2法门管理内部存储器。

在引用计数中,每2个对象承担爱惜对象拥有引用的计数值。当3个新的引用指向对象时,引用计数器就俯10皆是,当去掉多少个引用时,引用计数就递减。当引用计数到零时,该对象就将释放占有的能源。

咱俩通过开关房间的灯为例来�表明引用计数机制。

澳门葡京备用网址 1引用《Pro
Multithreading and Memory Management for iOS and OS X》中的图片

图中,“须求照明的食指”即对应大家要说的引用计数值。

  1. 首先私人住房进入办公室,“须要照明的人口”加壹,计数值从0变为一,因而须要开灯;
  2. 日后每当有人进入办公,“须要照明的人口”就加一。如计数值从一变成2;
  3. 每当有人下班离开办公,“须求照明的人头”加减1如计数值从2变成一;
  4. 谈起底1人下班离开办公室时,“须要照明的人头”减一。计数值从一变成0,由此须要关灯。

在Objective-C中,”对象“也正是办公的照明设备,”对象的利用条件“也就是进入办公的人。上班进入办公室的人对办公照明设备发出的动作,与Objective-C中的对应关系如下表

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

使用计数效率总括需求照明的食指,使办公室的照明获得了很好的管制。同样,使用引用计数成效,对象也就能收获很好的治本,那即是Objective-C内部存款和储蓄器管理,如下图所示

澳门葡京备用网址 2引用《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 自动释放,由自动释放池管理对象

循环引用场景:
1、block在主函数体用到了self / self.变量 / [self
方法],意味着:block对self 举行富有操作;
2、self评释了质量变量block,block用copy来修饰,意味着:self对block举行富有操作,会导致循环引用;
iOS中block的大循环引用难点,循环引用。譬如下图,将来那般写Xcode直接就会有警告出来告诉您这边貌似retain
cycle了啊!!

block使用对象被提前释放

有那种意况,即使不只是ClassA持有了myBlock,ClassB也兼具了myBlock。

澳门葡京备用网址 3

当ClassA被someObj对象释放后

澳门葡京备用网址 4

那儿,ClassA对象已经被释放,而myBlock还是被ClassB持有,未有自由;要是myBlock那些时被调度,而那时ClassA已经被放飞,此时作客的ClassA将是3个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

澳门葡京备用网址 5

注:如若是在M哈弗C形式下,使用__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还未被放飞。

 

在引用计数中,每1个对象承担维护对象具备引用的计数值。当三个新的引用指向对象时,引用计数器就俯十皆是,当去掉2个引用时,引用计数就递减。当引用计数到零时,该指标就将释放占有的能源。

巡回引用难点

三个目的相互持有,这样就会导致循环引用,如下图所示

澳门葡京备用网址 6七个目的互相持有

图中,对象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对象,此时的关系图如下。

澳门葡京备用网址 7

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

澳门葡京备用网址 8

不留余地办法:

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

使用__weak修饰self,使其在block中不被有着,打破循环引用。初步景况如下

澳门葡京备用网址 9

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

澳门葡京备用网址 10

事实上以上循环引用的意况很简单觉察,因为那时候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;}

澳门葡京备用网址 11

缓解格局:

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

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

注:以上使用__weak打破循环的办法只在ATiguanC下才使得,在MSportageC下相应使用__block

抑或,在block执行完后,将block置nil,那样也能够打破循环引用

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

诸如此类做的缺陷是,block只会实施2回,因为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只是叁个一时半刻变量,self并从未对其具备,所以并未有导致循环引用

看下边例子,有那种气象,假如不只是ClassA持有了myBlock,ClassB也具有了myBlock。

澳门葡京备用网址 12

当ClassA被someObj对象释放后

澳门葡京备用网址 13

那时候,ClassA对象已经被保释,而myBlock依旧被ClassB持有,未有自由;尽管myBlock这些时被调度,而此时ClassA已经被放走,此时做客的ClassA将是2个nil对象(使用__weak修饰,对象释放时会置为nil),而吸引错误。

另二个科学普及错误选拔是,开发者担心循环引用错误(如上所述不会冒出循环引用的场合),使用__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必须自个儿retain1次对象,职务到位后再release对象。但此处运用__weak,使dispatch_async未有增添self的引用计数,那使得在系统在调度执行block此前,self也许已被灭绝,但系统并不知道那么些情景,导致block执行时访问已经被放飞的self,而达不到预期的结果。

注:假如是在M哈弗C格局下,使用__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的轮回引用难题

大家通过开关房间的灯为例来�表明引用计数机制。

设若我想在block里面改变壹些变量的值只怕利用部分变量,如下图那样写Xcode间接报错
而且付出了解决方法提示出来了
那一点还挺机智的,那么我们选择__block修饰之后,再一次在block里面使用,就不会出难点了,完美。

澳门葡京备用网址 14

澳门葡京备用网址 15

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

解决

图中,“须要照明的人头”即对应大家要说的引用计数值。

先是私家进入办公,“须要照明的人数”加一,计数值从0变为一,由此须要开灯;

澳门葡京备用网址 16

日后每当有人进来办公室,“须要照明的人数”就加1。如计数值从一变成二;

运用部分变量.png

每当有人下班离开办公室,“需求照明的人口”加减一如计数值从二变成1;

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

最后1位下班离开办公时,“须要照明的人口”减壹。计数值从1变成0,因而需求关灯。

至于——Block在M奥德赛C和ASportageC形式的不一样
1)__block在M智跑C下有多个效益
同意在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只是贰个临时变量,self并不曾对其持有,所以并未有造成循环引用

澳门葡京备用网址 17

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

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

  • 再有一种意况,block属于Person对象,在另1个类里面使用的时候从不构成互顶牛有,那时候也不供给weakSelf。

  • 使用GCD的时候,这么写实际是荒谬的,并不是探望block就要为了幸免循环引用而采用weakSelf,像上面那种写法,正是漏洞百出的:

M索罗德C(马努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必须团结retain3次对象(即self),任务到位后再release对象(即self)。但那边运用__weak,使dispatch_async未有增添self的引用计数,那使得在系统在调度执行block在此之前,self大概已被灭绝,但系统并不知道这些情景,导致block执行时访问已经被放飞的self,而达不到预期的结果。

alloc/new/copy/mutableCopy创制对象,引用计数加1

总结
1 在 Block 内假设急需拜访 self 的法子、变量,提出选择 weakSelf。
二 尽管在 Block 内供给反复 访问 self,则要求采用 strongSelf。

retain引用计数加一

release引用计数减一

dealloc当引用计数为0时调用

[NSArray array]引用计数不扩展,由活动释放池管理

[NSDictionary dictionary]引用计数不扩大,由活动释放池管理

机动释放池

关于机关释放,不是本文的基本点,这里就不讲了。

A揽胜C(Automatic Reference Counting)中内部存储器管理

Objective-C对象所有权修饰符表达

__strong对象默许修饰符,对象强引用,在对象超过功效域时失效。其实就一定于retain操作,超出成效域时执行release操作

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

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

__autoreleasing自动释放,由自动释放池管理对象

block的基本知识

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

循环引用难题

多个指标互相持有,那样就会导致循环引用,如下图所示

澳门葡京备用网址 18

三个对象互相持有

图中,对象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],因为一旦
block中用到了目的的性情可能函数,block就会怀有该对象而不是该对象中的某些属性或然函数。

当有someObj持有self对象,此时的涉嫌图如下。

澳门葡京备用网址 19

当someObj对象release
self对象时,self和myblock彼此引用,retainCount都为一,造成循环引用

澳门葡京备用网址 20

消除方式:

__weak typeof(self) weakSelf = self;

self.myBlock = ^() {

NSString *localString = weakSelf.blockString;

};

使用__weak修饰self,使其在block中不被全体,打破循环引用。起首处境如下

澳门葡京备用网址 21

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

澳门葡京备用网址 22

实质上以上循环引用的状态很简单发觉,因为那时候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;

}

澳门葡京备用网址 23

焚林而猎办法:

– (void)testBlockRetainCycle {

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

__weak typeof(objB) weakObjB = objB;

self.myBlock = ^() {

[weakObjB doSomething];

};

objB.objA = self;

}

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

注:以上使用__weak打破循环的措施只在ALANDC下才使得,在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只会实施一回,因为block被置nil了,要再度使用以来,要求重新赋值。

1对不会导致循环引用的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只是一个暂时变量,self并不曾对其拥有,所以并未有导致循环引用

block使用对象被提前获释

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

澳门葡京备用网址 24

当ClassA被someObj对象释放后

澳门葡京备用网址 25

此刻,ClassA对象已经被放走,而myBlock依然被ClassB持有,未有自由;即便myBlock这么些时被调度,而此时ClassA已经被释放,此时拜会的ClassA将是多个nil对象(使用__weak修饰,对象释放时会置为nil),而引发错误。

另贰个广阔错误选用是,开发者担心循环引用错误(如上所述不会产出循环引用的景况),使用__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必须协调retain三遍对象(即self),职责成功后再release对象(即self)。但此间运用__weak,使dispatch_async未有扩充self的引用计数,那使得在系统在调度执行block从前,self也许已被销毁,但系统并不知道那么些情状,导致block执行时访问已经被假释的self,而达不到预期的结果。

注:要是是在MENCOREC格局下,使用__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执行进度中目的被放走

再有一种处境,在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执行实施以前已经被释放了,该格局也行不通。

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website