iOS中block的使用、实现底层、循环引用、存储位置

一、整体介绍

定义：C语言的匿名函数,􏰀提前准备一段代码,在需要的时候调用。

底层：是一个指针结构体,在终端下可以通过`clang -rewrite-objc 文件名`（会在当前目录生成.cpp文件）指令看看c++代码，它的实现底层。

二、内存位置（ARC情况）

block块的存储位置（block块入口地址）：可能存放在2个地方：代码区（NSConcreteGlobalBlock）、堆区（NSConcreteMallocBlock），程序分5个区，还有常量区、全局区和栈区，对于MRC情况下代码还可能存在栈区(NSConcreteStackBlock)。关于内存分区详细参考：http://www.jianshu.com/p/d85a5e56c505

情况1：代码区

不访问处于栈区的变量（例如局部变量），且不访问处于堆区的变量(例如alloc创建的对象)。也就是说访问全局变量也可以。

/**
没有访问任何变量
*/
int main(int argc, char * argv[]) {
void (^block)(void) = ^{
NSLog(@"===");
};
block();
}
/**
访问了全局（静态）变量
*/
int  iVar = 10;
int main(int argc, char * argv[]) {
void (^block)(void) = ^{
NSLog(@"===%d",iVar);
};
block();
}

情况2：堆区

如果访问了处于栈区的变量（例如局部变量），或处于堆区的变量(例如alloc创建的对象)。都会存放在堆区。(实际是放在栈区，然后ARC情况下自动又拷贝到堆区)

/**
访问局部变量
*/
int main(int argc, char * argv[]) {
int iVar = 10;
void (^block)(void) = ^{
NSLog(@"===%d",iVar);
};
block();
}

总结下：

代码区：不访问处于栈区的变量（例如局部变量），且不访问处于堆区的变量(例如alloc创建的对象)。也就是说访问全局变量（静态变量）也可以，或者是什么变量都不访问

堆区：如果访问了处于栈区的变量（例如局部变量），或处于堆区的变量(例如alloc创建的对象)，即便也访问了全局变量

三、注意事项

1 block为空

代码存放在堆区时，就需要特别注意，因为堆区不像代码区不变化，堆区是不断变化的（不断创建销毁）。因此代码有可能会被销毁（当没有强指针指向时），如果这时再访问此段代码则会程序崩溃。因此，对于这种情况，我们在定义一个block属性时应指定为strong，或copy:

@property (nonatomic, strong) void (myBlock)(void); // 这样就有强指针指向它

@property (nonatomic, copy) void (myBlock)(void); // 并不会在堆区copy一份，原因见 四

而对于block代码存在代码区，使用strong，copy(不会复制一份到堆区)也可以。因此定义block时最好指定为strong(推荐)或copy。我们在使用时最后判断下block是否为空，例如：

- (void)blockTest {
// 如果为空则返回
if (!block) {
NSLog(@"block is nil");
return;
}
block();
　　
}

2 当不在使用指向block的指针时，将其置空

当有类对象的成员变量pBlock指向block时，一方面是调用方，调用pBlock调用完成后，应将pBlock置为nil;另一方面是被调用方即block函数内部使用到self时要

__weak

声明。其实

__weak

声明有很多注意事项，下面是一个经典例子（是正确的写法）：

// 弱声明，防止block强引用self，造成循环引用
__weak __typeof(self) weakSelf = self;
self.observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"blockTest" object:nil queue:nil usingBlock:^(NSNotification * _Nonnull note) {
// 多线程情况下（假设发出通知的代码在另一线程下），strong强引用防止后面调用strongSelf时：前面的strongSelf正常，后面的strongSelf已在其它线程被释放，造成很奇怪的结果，虽然这种情况很少发生
__strong __typeof(self) strongSelf = weakSelf;
//if (strongSelf == nil) {
//    return;
//}
// 下面再对strongSelf进行访问
// 防止block为空
if (!strongSelf.block) {
return;
}
strongSelf.block();
// 如果不用应置空，养成好习惯
strongSelf.block = nil;
NSLog(@"%@",strongSelf);
}];

1）我们都知道在使用通知中心时，应在dealloc函数中释放通知，如果上面没有使用__weak声明，那么：通知中心持有self.observer，observer又强引用 usingBlock，usingBlock又强引用self，self就不会被释放，那么dealloc就不会被调用(即使在dealloc中写了

[[NSNotificationCenter defaultCenter] removeObserver:self.observer]

也不会调用，因为dealloc没有被调用)，就造成内存泄露；

2）另外，我们在第5行看到又使用了

__strong

声明，是否瞬间凌乱？下面给出解释：在多线程情况下，有可能在usingBlock调用时，执行

if (!strongSelf.block)

时strongSelf还没有释放，而执行到

strongSelf.block()

的时候strongSelf就被释放(现在没有强引用了，又开始担心self被释放，真是操碎了心。。。)，造成调用失败（最大的问题是不统一，造成不可预知的错误。用

__strong

操作后保证要么都访问成功，要么都访问失败或者判断为空后直接return退出）。

而使用了__strong声明后：

如果执行usingBlock时self已经被释放则后面的strongSelf均为nil，因为对weakSelf引用计数为0再retain一次也不会有变化；

如果执行usingBlock时self没有释放，则strongSelf会使self引用计数+1，那么self在其它线程被release -1也不会有影响，只有到usingBlock全部执行完毕后，strongSelf释放，然后self引用计数-1，self才会释放（weak–strong dance）。

上面的例子是通知中心可能造成的内存泄露，而使用block还经常出现循环引用，如下：

3 最常出现的循环引用

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

@implementation BlockViewController

- (void)viewDidLoad {
[super viewDidLoad];
self.block = ^{
self.str = @"123";
};
}
@end

上面的代码，self.block强引用block，而block中又使用了self.str，所以block强引用self，造成强引用，解决方法使用2中所说即可。

关于引用计数(http://www.jianshu.com/p/28b074919df3)

四、关于捕获变量

block里面捕获的变量，都是副本。看下面一段代码

int val = 10;
void (^block)(void) = ^{
NSLog(@"val = %d",val);
// val = 1; //不允许
};
val = 5;
block();

它的打印结果是10，而不是5。

上面代码中

val = 1

是不允许的，如果想实现写操作，可以使用__block来修饰val，之后val会被拷贝(移动,便于理解)到堆上，之后无论是在block里面还是在val之前所处的作用域，访问的都是出于堆区的val。


但是在block里面，类似

self.name = xxx,self->_val

，却是很常见的，self也没有用__block修饰呀！你是否有过这样的迷惑？

self.name = xxx

——>

[self setName:xxx];

是发送消息，函数调用，很好理解。那

self->_val

呢？因为_val本身是处于堆区的。

五、指定为copy后是否会拷贝一份呢？（或者说是浅拷贝还是深拷贝）

1 copy可变变量：在赋值指针的同时也会复制指针指向的内存区域。深拷贝，例如NSMutableString对象。

2 copy不可变变量：等同于strong，还是浅拷贝，例如NSString对象。

因为block是一段代码，即不可变的，所以并不会深拷贝。

六、一些思考

block也是属于“函数”的范畴，即一段代码。为什么要将其放在堆区呢，而不是直接在代码区呢？

试想一下，如果不放到堆区，而放在代码区，那么block捕获的self对象将永远不会释放，因为代码区的block是不会释放的，那内存的泄露可就随处可见了。。。

所以苹果这么做也是有原因的