俄罗斯贵宾会-俄罗斯贵宾会官网
做最好的网站

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的循环引用问题

MRC(Manual Reference Counting)中引起应用计数变化的方法

大部分GCD方法

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

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

 

}

不会造成循环引用的block

ARC(Automatic Reference Counting)中内存管理

block使用对象被提前释放

有这种情况,如果不只是ClassA持有了myBlock,ClassB也持有了myBlock。

图片 1

当ClassA被someObj对象释放后

图片 2

此时,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,而达不到预期的结果。

 

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

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并没有对其持有,所以没有造成循环引用

 

}

注:如果是在MRC模式下,使用__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还未被释放。

 

self.myBlock = ^() {

self.myBlock = ^() {

objA.objA = self;

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

- (void)doSomething {

图片 3

关灯废弃对象

self.myBlock = ^() {

引用计数(Reference Count)

- (void)testBlockRetainCycle {

图片 4

NSString *localString = weakSelf.blockString;

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

[NSDictionary dictionary]引用计数不增加,由自动释放池管理

self.myBlock = ^() {

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

__weak MyClass* weakSelf = self;

//NSString *localString = _blockString;

block的基本知识

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

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

一些不会造成循环引用的block

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

retain引用计数加1

图片 5

循环引用问题

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

不需要照明释放对象

//ClassB

图片 6

objB.objA = self;

解决方法:

[self test];

iOS的内存管理机制

dispatch_async(dispatch_get_main_queue(), ^{

当ClassA被someObj对象释放后

图中,“需要照明的人数”即对应我们要说的引用计数值。

该场景下的代码

[objB doSomething];

dealloc当引用计数为0时调用

@property (copy, nonatomic) block myBlock;

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

- (void)testBlock {

使用计数功能计算需要照明的人数,使办公室的照明得到了很好的管理。同样,使用引用计数功能,对象也就能得到很好的管理,这就是Objective-C内存管理,如下图所示

- (void)testBlockRetainCycle {

}

};

__strong对象默认修饰符,对象强引用,在对象超出作用域时失效。其实就相当于retain操作,超出作用域时执行release操作

});

关于自动释放,不是本文的重点,这里就不讲了。

__weak typeof(self) weakSelf = self;

}

- (void)testBlockRetainCycle {

对于这种场景,应该在block中对 对象使用__strong修饰,使得在block期间对 对象持有,block执行结束后,解除其持有。

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

}

};

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

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

self.myBlock = ^() {

block执行过程中对象被释放

运行结果

[self doSomething];

@property (copy, nonatomic) NSString *blockString;

解决方法:

}

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

//[self doSomething];

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

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

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

[5988:435396] self:(null)

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

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

两个对象相互持有

self.myBlock = nil;

__weak typeof(objA) weakObjA = objA;

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

[NSArray array]引用计数不增加,由自动释放池管理

}];

Objective-C对象方法说明

block();

dispatch_async(dispatch_get_main_queue(), ^{

__weak typeof(self) weakSelf = self;

本文由俄罗斯贵宾会发布于编程,转载请注明出处:Block 循环引用(中)

您可能还会对下面的文章感兴趣: