在iOS开发中,循环引用是个老生常谈的问题.delegate为啥使用weak修饰,block为什么需要weakSelf或strongSelf?通过阅读他人的文章并结合自己理解来阐述一下自己对循环引用的理解,若有不足希望大家指出.

内存的基础知识

首先需要先了解内存中的分区:栈区、堆区、静态区(全局区).具体职责划分如下:

栈区(stack):
- 存放局部变量,先进后出,一旦出了作用域就会被销毁,函数跳转地址,现场保护等
- 程序猿不需要管理栈区变量的内存
- 栈区的地址从高到低分配
堆区(heap):
- 堆区的内存分配使用的是alloc;
- 需要程序猿管理内存
- ARC的内存管理,是编译器在编译的时候自动添加retain,release,autorelease;
- 堆区的地址是从低到高分配
全局区/静态区(staic) :
- 包括2个部分:未初始化和初始化; 也是说,在内存中是放在一起的,比如:int a;未初始化, int a = 10 初始化的,两者都在全局区/静态区
- 常量区:常量字符串及时放在这里的
- 代码区:存放app代码

如图所示:

可以看见在上面的说明中,只有堆区是需要程序员管理的,而循环引用也与此有关,所以我们一般只需要关注堆区内存就可以了,即循环引用导致堆中的内存无法正常回收.那么内存的回收又和我们iOS的回收机制有关,也就是大家都知道的引用计数:

对堆里面的一个对象发送release消息来使其引用计数减一；
查询引用计数表，将引用计数为0的对象dealloc；用比较经典的图来说明一下:

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

"对象"就相当于上图中的灯,而"持有对象"就相当于图中的人.第一个进来打开灯的人相当于进行了一个alloc操作,创建了对象这块内存,并使引用计数变为1.之后进来的人就相当于持有这个对象,使引用计数+1(retain),离开的人就使该对象引用计数-1(release).只要办公室里面还有人在(还有人持有这个对象),这个"灯"就不会关(dealloc).最后一个人走了,那么灯就关了,这块内存也就被成功释放了. 过程如图所示

正常的内存释放过程

正常的内存释放过程是这样的,B对象是A对象的一个属性,也就是A持有B,现在要释放掉A了,给A发一个release消息,这个时候A的引用计数变为0,就要走dealloc方法,在dealloc方法里面会给A持有的所有对象发送一条release消息,当然包括B,也就是[B release].然后B的引用计数也变为0,执行dealloc.这样A和B就都释放掉了,没有造成任何内存问题,内存正确回收.

循环引用的产生

那么什么时候会造成循环引用呢,顾名思义,就是互相持有,形成一个闭环,导致谁也无法正确释放.如图所示:

造成循环引用的过程是这样的:想要让A释放,需要B给A发送release消息,因为此时B持有A,但B只有在dealloc的时候会发送release消息,要让B执行dealloc方法,就需要A发送release消息给B,要让A发送release消息给B就需要A执行dealloc方法,要让A执行dealloc方法又需要B给A发送release消息...这样循环往复,都在等对方给自己发送release消息,造成谁也无法dealloc,内存也就无法释放.就像两个人都拽着对方的手说你先松我才松一样,谁都不肯先松,然后就这样一直拽着对方直到天荒地老. 这种感觉就像下面这张图一样:

循环引用的例子与解决方案

1.delegate

//ClassA:
@protocol ClssADelegate <NSObject>
－ (void)doNothing;
@end
@interface ClassA : UIViewController
@property (nonatomic, strong) id <ClssADelegate> delegate;
@end

//ClassB:
@interface ClassB ()<ClassADelegate>
@property (nonatomic, strong) ClassA *classA;
@end
@implementation ClassB
－ (void)viewDidLoad {
    [super viewDidLoad]; 
    self.classA = [[ClassA alloc] init];  
    self.classA.delegate = self;
}

在上面的代码中,classB持有classA,而classA中delegate属性使用strong强引并指向了self(classB),所以classA通过delegate持有了classB.这样就造成了循环引用.大家可能都知道该如何解决这个问题,那就是使用weak替代strong.这也是为什么delegate通常都用weak修饰的原因.这里顺便简单说一下weak吧. weak是弱引用，用weak描述修饰或者所引用对象的计数器不会加一，并且会在引用的对象被释放的时候自动被设置为nil，大大避免了野指针访问坏内存引起崩溃的情况，另外weak还可以用于解决循环引用.

2.Block

@interface ClassA ()
@property (nonatomic, copy) Block block;
@property (nonatomic, assign) NSInteger num;
@end
@implementation ClassA
- (void)viewDidLoad {
    [super viewDidLoad];
    self.block = ^{
        self.num = 1;
    };  
}

在上面的代码中的block是存在于堆内存中,classA持有block,而堆内存中的block中又持有了self,这样就造成了循环引用.如果是栈中的block就不会造成这种问题,如下所示:

 void (^block)(void) = ^{
        self.num = 1;
    };
 block();

要解决Block造成的这种循环引用,常用的解决方式是使用WeakSelf,如下:

@interface ClassA ()
@property (nonatomic, copy) Block block;
@property (nonatomic, assign) NSInteger num;
@end
@implementation ClassA
- (void)viewDidLoad {
    [super viewDidLoad];
    __weak typeof(self) weakSelf = self
    self.block = ^{
        weakSelf.num = 1;
    };  
}

在上面的两个例子中可以看出,使用weak弱引用替代strong强引用来让环消失是非常有效的方式,在大多数情况下用这种方法就可以了,但在某些情况下还是有缺陷的

3.weak-strong dance

有一种场景就是在block执行过程,self被释放掉了,这个时候如果去访问self的话就会发生错误.代码如下:

#import "ControllerB.h"

@interface ControllerB ()
@property (nonatomic,copy) void (^block)(void);
@property (nonatomic, strong) NSString *str;
@end

@implementation ControllerB

- (void)viewDidLoad {
    [super viewDidLoad];
    self.str = @"test";
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", weakSelf.str);
        });
    };
    self.block();
}

ControllerA push到ControllerB中,如果在4秒没有pop回去的话,B中的block会打印出test.否则会打印出(null).这种情况是因为内存提前回收,也就是需要用到self的时候,self已经置为nil了.

那么这个时候就需要在block强引用self,直到block执行再释放掉self.代码如下:

#import "ControllerB.h"

@interface ControllerB ()
@property (nonatomic,copy) void (^block)(void);
@property (nonatomic, strong) NSString *str;
@end

@implementation ControllerB

- (void)viewDidLoad {
    [super viewDidLoad];
    self.str = @"test";
    __weak typeof(self) weakSelf = self;
    self.block = ^{
        __strong typeof(self) strongSelf = weakSelf;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", strongSelf.str);
        });
    };
    self.block();
}

strongSelf是个局部变量,存在于栈中,而栈中内存系统会自动回收,也就是在block执行结束后回收,不会造成循环引用.同时strongSelf使ControllerB的引用计数加1,致其在pop后不会立马执行dealloc销毁str属性,因为此时strongSelf持有了ControllerB,4秒过后,block执行并打印str,局部变量strongSelf被系统回收,其持有的ControllerB也会执行dealloc方法.

@weakify和@strongify

之前用RAC的时候看见里面的宏定义@weakify和@strongify,觉得非常高明.这样的话不仅很方便,而且防止不小心在block中使用self造成的循环引用. 那么上面的ControllerB的代码就可以改成这样:

#import "ControllerB.h"

@interface ControllerB ()
@property (nonatomic,copy) void (^block)(void);
@property (nonatomic, strong) NSString *str;
@end

@implementation ControllerB

- (void)viewDidLoad {
    [super viewDidLoad];
    self.str = @"test";
     @weakify(self)
    self.block = ^{
    @strongify(self)
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", self.str);
        });
    };
    self.block();
}

这样就可以随意的在block中使用self了