iOS中block的循环引用问题

转载链接:http://www.jianshu.com/p/492be28d63c4

作者:HK_Hank

通过这篇文章,block的学习基本就万事大吉了,感谢原创作者的无私分享。

本文主要介绍ARC下block的循环引用问题,举例说明引起循环引用的场景和相应的解决方案。

在讲block的循环引用问题之前,我们需要先了解一下iOS的内存管理机制和block的基本知识

iOS的内存管理机制

Objective-C在iOS中不支持GC(垃圾回收)机制,而是采用的引用计数的方式管理内存。

引用计数(Reference Count)

在引用计数中,每一个对象负责维护对象所有引用的计数值。当一个新的引用指向对象时,引用计数器就递增,当去掉一个引用时,引用计数就递减。当引用计数到零时,该对象就将释放占有的资源。

我们通过开关房间的灯为例来说明引用计数机制。

iOS中block的循环引用问题_第1张图片
引用《Pro Multithreading and Memory Management for iOS and OS X》中的图片

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

  1. 第一个人进入办公室,“需要照明的人数”加1,计数值从0变为1,因此需要开灯;
  2. 之后每当有人进入办公室,“需要照明的人数”就加1。如计数值从1变成2;
  3. 每当有人下班离开办公室,“需要照明的人数”加减1如计数值从2变成1;
  4. 最后一个人下班离开办公室时,“需要照明的人数”减1。计数值从1变成0,因此需要关灯。

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

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

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

iOS中block的循环引用问题_第2张图片
引用《Pro Multithreading and Memory Management for iOS and OS X》中的图片

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

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

自动释放池

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

ARC(Automatic Reference Counting)中内存管理

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

block的基本知识

block的基本知识这里就不细说了,可以看看我的文章说说Objective-C中的block

循环引用问题

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

iOS中block的循环引用问题_第3张图片
两个对象相互持有

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


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


解决方法:

__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;
}
iOS中block的循环引用问题_第4张图片

解决方法:

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

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

注:以上使用__weak打破循环的方法只在ARC下才有效,在MRC下应该使用__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了,要再次使用的话,需要重新赋值。

一些不会造成循环引用的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。

iOS中block的循环引用问题_第5张图片

当ClassA被someObj对象释放后


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

注:如果是在MRC模式下,使用__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执行执行之前已经被释放了,该方法也无效。


你可能感兴趣的:(iOS)