准备工作
1. block的分类
block的分类主要分为以下的三种：
__NSGlobalBlock__ 全局block__NSStackBlock__ 栈区block__NSMallocBlock__ 堆区block
block在MRC和ARC环境出现的情况：
-
MRC环境下
引入以下的案例：
void(^block)(void);
int aa = 0;
NSLog(@"\n********A**********");
void (^blockA)(void) = ^{
};
NSLog(@"blockA is : %@ -----retainCount : %lu", blockA, [blockA retainCount]);
block = [blockA copy];
NSLog(@"copy blockA is : %@ -----retainCount : %lu", block, [blockA retainCount]);
NSLog(@"\n********B**********");
void (^blockB)(void) = ^{
NSLog(@"hello aa %d", aa);
};
NSLog(@"blockB is : %@ -----retainCount : %lu", blockB, [blockB retainCount]);
block = [blockB copy];
NSLog(@"copy blockB is : %@ -----retainCount : %lu", block, [block retainCount]);
运行结果如下：
由以上的案例运行结果可知，
blockA与blockB的差异只在于有没有调用外部变量，这点差异导致它们的类型不同，存储位置不同。
NSGlobalBlock
block内部没有引用外部变量，Block类型都是NSGlobalBlock类型，存储于全局数据区，由系统管理其内存，retain、copy、release操作都无效。如果访问了外部static或者全局变量也是这种类型。NSStackBlock
block内部引用外部变量，retain、release操作无效，存储于栈区，变量作用域结束时，其被系统自动释放销毁。NSMallocBlock
上例中的[blockB copy]操作后变量类型变为NSMallocBlock，支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数，当引用计数为零的时候释放。ARC环境下
引入以下的案例：
void(^block)(void);
int aa = 0;
NSLog(@"\n********A**********");
void (^blockA)(void) = ^{
};
NSLog(@"blockA is : %@ -----retainCount : %lu", blockA, CFGetRetainCount(((__bridge CFTypeRef)blockA)));
block = [blockA copy];
NSLog(@"copy blockA is : %@ -----retainCount : %lu", block, CFGetRetainCount(((__bridge CFTypeRef)block)));
NSLog(@"\n********B**********");
void (^blockB)(void) = ^{
NSLog(@"hello aa %d", aa);
};
NSLog(@"blockB is : %@ -----retainCount : %lu", blockB, CFGetRetainCount(((__bridge CFTypeRef)blockB)));
block = [blockB copy];
NSLog(@"copy blockB is : %@ -----retainCount : %lu", block, CFGetRetainCount(((__bridge CFTypeRef)block)));
NSLog(@"\n********C**********");
void (^__weak blockC)(void) = ^{
NSLog(@"hello aa %d", aa);
};
NSLog(@"blockC is : %@ -----retainCount : %lu", blockC, CFGetRetainCount(((__bridge CFTypeRef)blockC)));
block = [blockB copy];
NSLog(@"copy blockC is : %@ -----retainCount : %lu", block, CFGetRetainCount(((__bridge CFTypeRef)block)));
运行结果如下：
查看运行结果发现，
blockB在MRC下是NSStackBlock类型，而在ARC下是NSMallocBlock类型。
-
NSGlobalBlock
此种情况和MRC一样，block内部没有引用外部变量的，Block类型都是NSGlobalBlock类型，存储于全局数据区，由系统管理其内存，如果访问了外部static或者全局变量也是这种类型。 -
NSStackBlock
访问了外部变量，但没有强引用指向这个block，如直接打印出来的block，如下：
弱引用block -
NSMallocBlock
ARC环境下只要访问了外部变量，而且有强引用指向该block(或者作为函数返回值)就会自动将__NSStackBlock类型copy到堆上。
2. block的内存分析
2.1 捕获外部变量引用计数案例分析
ARC环境，案例中定义了两个block，跟踪objc的引用计数变化。引入相关案例如下：
NSObject * objc = [NSObject alloc];
NSLog(@"objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)objc)));
void (^__weak blockA)(void) = ^{
NSLog(@"A objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)objc)));
};
blockA();
void (^blockB)(void) = ^{
NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)objc)));
};
blockB();
运行结果如下：
查看运行结果看出引用计数分别是
1，2，4，第一个是1应该多数人是没问题的，那么后面为什么是2，4呢？接着往下分析：
- 首先
objc对象创建好之后，调用CFGetRetainCount函数获取引用计数，此时应该为1； -
blockA为__weak，也就是没有强引用指向这个block，并且访问了外部变量，所以是NSStackBlock，因为blockA对变量objc进行了捕获，并在其结构体内部创建了一个objc的变量，所以此时引用计数应该变成2； -
blockB是一个NSMallocBlock，ARC环境下只要访问了外部变量，而且有强引用指向该block就会自动将__NSStackBlock类型copy到堆上，所以这个过程进行了一次block的copy，所以这个地方引用计数加2，变为4。
2.2 堆栈释放差异
-
差异1
首先还是引入以下的一个案例，查看运行的情况，如下：
- (void)blockDemo{
int a = 0;
void(^__weak weakBlock)(void) = nil;
{
void(^__weak strongBlock)(void) = ^{
NSLog(@"---%d", a);
};
weakBlock = strongBlock;
NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
}
weakBlock();
}
运行结果如下：
可以知道案例的运行是没有出现问题的，那么结果分析如下：
声明了一个
weakBlock，该block为NSStackBlock；在代码块中，定义了
strongBlock，其也为NSStackBlock；对
weakBlock进行了赋值，此时两个block均指向同一个NSStackBlock；因为这两个
栈block的生命周期到blockDemo方法运行结束，并不会被提前释放；所以调用
weakBlock()可以正常运行，并能够输出a的值。差异2
对上面的案例strongBlock修改成了NSMallocBlock，其他没有变化。如下：
- (void)blockDemo{
int a = 0;
void(^__weak weakBlock)(void) = nil;
{
void(^strongBlock)(void) = ^{
NSLog(@"---%d", a);
};
weakBlock = strongBlock;
NSLog(@"1 - %@ - %@", weakBlock,strongBlock);
}
weakBlock();
}
运行结果如下：
可以知道这个案例运行是有问题的，出现了崩溃，常规办法我们用
lldb调试看看：
结合
lldb调试结果分析：
-
strongBlock为NSMallocBlock，其生命周期范围在代码块{}内，也就是出了代码块其就会被释放； - 在代码块中对
weakBlock进行了赋值，指针拷贝，指向了对应的NSMallocBlock，但是并没有强引用指向这个block； - 代码块执行完毕后，该
NSMallocBlock就会被释放，此时weakBlock指向的对象已经被释放，形成野指针，所以无法正常执行。
lldb继续验证是否为指针拷贝，如下：
如果将weakBlock去掉__weak修饰呢？请继续往下看：
可以知道这样子是完全没有问题的，分析如下：
- 对
weakBlock进行了赋值时，weakBlock对堆中的block进行了强引用。所以代码块运行完后不会释放，能够正常运行。
3. block循环引用
众所周知，正常情况下，持有释放，按照下图的逻辑：
循环引用就是对方面持有导致对象不能正常释放，会发生
内存泄漏，如下：
3.1 循环引用的案例
引入一个循环引用的案例如下：
typedef void(^TBlock)(void);
@interface ViewController ()
@property (nonatomic, strong) TBlock block;
@property (nonatomic, copy) NSString *name;
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 循环引用
self.name = @"Hello";
self.block = ^(){
NSLog(@"%@", self.name);
};
self.block();
}
这里self持有了block，block持有了self，导致循环引用。编译时Xcode也会给出提示，在此块中强烈捕获self可能会导致循环循环。
特殊案例
以下代码并没有引起循环引用，如下：
- (void)viewDidLoad {
[super viewDidLoad];
// 循环引用
self.name = @"Hello";
void(^block)(void);
block = ^(){
NSLog(@"%@", self.name);
};
block();
}
为什么这个案例就没有出现循环引用的状况呢？因为当前self，也就是ViewController并没有对block进行强持有，block的生命周期只在viewDidLoad方法内，viewDidLoad方法执行完，block就会释放。
3.2 循环引用解决方法
最常用的也是我们最熟知的_weak。__weak之所以能够解决循环引用，根本原因是__weak不会对引用计数进行操作。
weak的使用
__weak typeof(self) weakSelf = self;
上面的案例修改成weak来避免循环引用如下：
// 循环引用
self.name = @"Hello";
__weak typeof(self) weakSelf = self;
self.block = ^(){
NSLog(@"%@", weakSelf.name);
};
self.block();
此时self持有block，block弱引用self，弱引用会自动变为nil，强持有中断，所以不会引起循环引用。
-
反面案例
如果在以上的案例中修改成如下的话，会发生代码执行过程中对象被释放的情况，如下：
反面案例
虽然没有引起循环引用，但是block中延迟2秒钟执行任务，如果此时ViewController被销毁，此时block已经无法获取ViewController的属性name，很不合理。那么要结果这个问题需要怎么操作呢？请继续往下！ 强弱共舞
将上面的案例再改进一下：
self.name = @"Hello";
__weak typeof(self) weakSelf = self;
self.block = ^(){
__strong __typeof(weakSelf)strongWeak = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", strongWeak.name);
});
};
self.block();
运行结果如下：
通过运行结果发现，完全解决了以上
self中途被释放的问题，这是为什么呢？分析如下：
在完成
block中的操作之后，才调用了dealloc方法。添加strongWeak之后，持有关系为：self->block->strongWeak->weakSelf->self。weakSelf被强引用了就不会自动释放，因为strongWeak只是一个临时变量，它的声明周期只在block内部，block执行完毕后，strongWeak就会释放，而弱引用weakSelf也会自动释放。手动中断持有关系
引入案例代码如下：
self.name = @"Hello";
__block ViewController * ctrl = self;
self.block = ^(){
__strong __typeof(weakSelf)strongWeak = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", ctrl.name);
ctrl = nil;
});
};
self.block();
运行结果如下：
使用
ctrl之后，持有关系为： self -> block -> ctrl -> self，ctrl在block使用完成后，被置空，至此block对self持有就解除，不构成循环引用。
-
block传参
block传参的方式解决循环引用问题，见下面代码：
// 循环引用
self.name = @"Hello";
self.block = ^(ViewController * ctrl){
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", ctrl.name);
});
};
self.block(self);
将self作为参数参入block中，进行指针拷贝，并没有对self进行持有。运行结果如下：
3.3 block循环引用案例
- 静态变量持有
// staticSelf_定义：
static ViewController *staticSelf_;
- (void)blockWeak_static {
__weak typeof(self) weakSelf = self;
staticSelf_ = weakSelf;
}
以上会出现循环引用，weakSelf虽然是弱引用，但是staticSelf_静态变量，并对weakSelf进行了持有，staticSelf_释放不掉，所以weakSelf也释放不掉！导致循环引用！
__strong持有问题
- (void)block_weak_strong {
__weak typeof(self) weakSelf = self;
self.doWork = ^{
__strong typeof(self) strongSelf = weakSelf;
NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)strongSelf)));
weakSelf.doStudent = ^{
NSLog(@"%@", strongSelf);
NSLog(@"B objc -----retainCount : %lu", CFGetRetainCount(((__bridge CFTypeRef)strongSelf)));
};
weakSelf.doStudent();
};
self.doWork();
}
同样这个案例也会出现循环引用的情况，分析如下：
- 在
doWork内部，__strong typeof(self) strongSelf = weakSelf; - 用强引用持有了
weakSelf，和前的情况类似，strongSelf的生命周期也就在doWork方法内; - 这里需要注意的是，
doStudent这个内部block调用了外部变量，所以他会从栈block copy到堆中，从而导致strongSelf的引用计数增加，无法释放掉，进而导致循环引用！
总结
这篇文章主要分析了block在开发过程中我们容易犯错的地方，下一篇文章我们就根据源码分析block底层究竟做了什么，请拭目以待！！哈哈
