前言
在我们的实际开发中，Block的使用率相当之高，我们在使用Block的时候，会遇到各种各样的问题，比如经典的循环引用，那么这些问题到底是怎么产生的，我们又该如何去解决，这就需要我们对Block有深入的了解，才能更好的解决这些问题，今天我们就来深入分析一下Block。
1 Block的类型
我们知道Block分为全局Block、栈Block、堆Block。我们怎么区分或者判断是哪种Block呢，我们来分析下。
int a = 10;
void (^block)(void) = ^{
//NSLog(@"robert - %d",a);
};
这是一个全局的Block，我们看下效果，如图：
我们把NSLog这行代码打开，再次运行，看下效果
这是一个堆Block。
在ARC下，我们怎么打印出栈Block呢，我们把代码改成这样
int a = 10;
void (__weak ^block)(void) = ^{
NSLog(@"robert - %d",a);
};
再次运行，如图所示
这是一个栈Block。
Block类型划分，具体点，我们该怎么区分，如下所示，
GlobalBlock
- 位于全局区。
- 在Block内部不使用外部变量，或者只使用静态和全局变量。
MallocBlock
- 位于堆区。
- 在Block内部使用局部变量或者OC属性，并且赋值给强引用或者Copy修饰的变量。
StackBlock
- 位于栈区。
- 与MallocBlock一样，可以在内部使用局部变量或者属性，但是不能赋值给强引用或者Copy修饰的变量。
全局Block比较好区分，MallocBlock和StackBlock不易区分， 下面我们来看这样一段代码
- (void)blockRetaincount{
NSObject *objc = [NSObject new];
NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
void(^strongBlock)(void) = ^{
NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
};
strongBlock();
void(^__weak weakBlock)(void) = ^{ // + 1
NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
};
weakBlock();
void(^mallocBlock)(void) = [weakBlock copy];
mallocBlock();
}
请问这里的打印是多少？
我们运行一下，看下效果，如图
为什么结果是这样呢的？需要我们具体分析下。
*NSObject objc = [NSObject new];这里之后obj的引用计数为1
void(^strongBlock)(void) = ^{
NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
}; 这是为什么是3呢，因为strongBlock外部捕获了objc，进行了copy操作，引用计数+1，strongBlock是一个MallockBlock,会进行强持有，从栈上拷贝堆上，这个时候堆上的对象引用计数再次+1，就变成了3。void(^__weak weakBlock)(void) = ^{ // + 1
NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));
}; 这是一个栈Block，因为weakBlock外部捕获了objc，进行了copy操作，引用计数+1 ，但是它是一个栈Block，不会从栈上拷贝堆上，所以这里打印4。void(^mallocBlock)(void) = [weakBlock copy]; 这里对weakBlock进行一次copy操作，从栈上拷贝到堆上，这个时候堆上的对象引用计数+1,所以这里打印5。
我们接着再看一段代码，如下所示
- (void)blockCopy{
int a = 0;
void(^ __weak weakBlock)(void) = ^{
NSLog(@"-----%d", a);
};
struct _RoBlock *blc = (__bridge struct _RoBlock *)weakBlock;
id __strong strongBlock = weakBlock;
blc->invoke = nil;
void(^strongBlock1)(void) = strongBlock;
strongBlock1();
}
这段代码的执行结果是什么？
我们来运行下，看下效果，如图
这里闪退了，我们来分析下。
blc->invoke这里的invoke进行调用执行。
struct _RoBlock *blc = (__bridge struct _RoBlock *)weakBlock; 这里把weakBlock进行强转。
id __strong strongBlock = [weakBlock copy]; 这里把weakBlock进行copy操作。
blc->invoke = nil; 把blc的invko置空。
void(^strongBlock1)(void) = strongBlock;这段代码只是强转一次，把strongBlock具有block的特性，可以调用执行。
说明weakBlock强转成blc时，他们还是指向同一块内存区域，blc的invoke为nil，那么weakBlock的invoke也是nil，所以这里调用的时候闪退。
如何来解决呢，我们可以进行copy操作，id __strong strongBlock = weakBlock; 改成
id __strong strongBlock = [weakBlock copy]; 我们再试下，如图
这样就就正常了，一定要在blc->invoke = nil;之前进行copy操作。
我们再分析一段这代码，如下所示
- (void)blockDemo{
// NSObject *a = [NSObject alloc];
int a = 0;
void(^__weak weakBlock)(void) = nil;
{
void(^__weak strongBlock)(void) = ^{
NSLog(@"strongBlock ---%d", a);
};
weakBlock = strongBlock;
NSLog(@"1");
}
weakBlock();
}
请问这段代码的执行结果是什么？
我们来运行下，看下效果，如图
我们分析下它的执行流程是什么。
- void(^__weak weakBlock)(void) = nil;这是一个栈Block
- void(^__weak weakBlock)(void) = nil;
{
void(^__weak strongBlock)(void) = ^{
NSLog(@"strongBlock ---%d", a);
};
weakBlock = strongBlock;
NSLog(@"1");
}
weakBlock();
}这里一个代码块，跟void(^__weak weakBlock)(void) = nil;无关 - 在代码块中strongBlock是一个栈Block
- 把strongBlock给了weakBlock， weakBlock也是一个栈Block
- 栈Block的生命周期是在blockDemo这个方法中，也就是说只有出了这个方法，这个栈Block的生命周期才会结束，所以这里运行是正常的。
我们改下代码，反* void(^__weak strongBlock)(void) = ^{改成 * void(^strongBlock)(void) = ^{ ，看下运行效果，如图
这里闪退了。
原因分析Block默认是强引用的，这里是在堆区，它的生命周生期是在代码块中，出了代码块，它就会被锁毁，weakBlock = strongBlock;赋值后，weakBlock也是在堆区，所以这里调用weakBlock()就会闪退。
我把weakBlock = strongBlock;改成weakBlock = [strongBlock copy];同样会闪退，原因同上，因为也是在堆区，出了代码块，销毁了。
Block循环引用的分析
我们看下这张图，
A对于进行B持有， A会对B进行引用计数+1的操作，当B要想释放掉的，需要等待A发送realses信号，如果B的引用计数为0的时候，dealloc就会被调用，只有当A在dealloc的时候会发送信号给B。
这张图描述了，A持有B，B也同时持有了A，这个时候就构成了无法释放的循环，因为B的释掉依赖A的释放，A的释放又依赖的B的释放，产生了循环引用。
我们先来段代码，案例1
- (void)test1 {
self.name = @"robert";
self.block = ^(void) {
NSLog(@"%@", self.name);
};
self.block();
}
- (void)dealloc{
NSLog(@"dealloc走你");
}
我们运行一下，看下dealloc是否调用了，如图
这里没有打印，说明这里产生循环引用，
这段代码，案例2
[UIView animateWithDuration:1 animations:^{
NSLog(@"%@", self.name);
}];
运行效果，如图
这里可以看出调用了dealloc，所以没有产生循环引用，这是为什么，我们分析下。
案例1中，self->block->self 产生循环引用
__weak typedef(self) weakSelf = self;使用weak指针来解决
我们再改一下代码，如下
- (void)test1 {
__weak typeof(self)weakSelf = self;
self.name = @"robert";
self.block = ^(void) {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)3*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
NSLog(@"name=%@", weakSelf.name);
});
};
self.block();
}
看下它的执行效果，如图
name的值打印出来了空，这是为什么呢，我们只不过延迟几秒种调用而已，发生了什么事情？
分析，当我们返回上个页面时，self被释放掉了，weakSelf也被释放掉了，这个时候再调用就是nil。
我们可以通过__strong __typeof(weakSelf)strongSelf = self;来解决，如代码所示
- (void)test1 {
__weak typeof(self)weakSelf = self;
self.name = @"robert";
self.block = ^(void) {
__strong __typeof(weakSelf)strongSelf = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)3*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
NSLog(@"name=%@", strongSelf.name);
});
};
self.block();
}
运行结果如下
这里运行就正常了。
也就是说通过weak-strong-dance的方法解决。
strongSelf虽然是强引用，是个临时变量，它的生命周期是在block的范围内，会自动释放。
我们再来讲第二种方示，代码如下：
__block SecondViewController *vc = self;
self.name = @"robert";
self.block = ^(void) {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)3*NSEC_PER_SEC), dispatch_get_main_queue(), ^{
NSLog(@"name=%@", vc.name);
vc = nil;
});
};
self.block();
}
运行结果，如图
vc被self.block持有了，但是我们把vc置空,断开了循环。
self->block->vc->self,vc=nil断开了循环链。
对外部变量操作加上__block的才能修改，后续会详细讲。
当然我们还可以通过传参的方式来解决。
我们再来看一段代码，如下所示：
static SecondViewController *staticSelf_;
- (void)blockWeakStatic {
__weak typeof(self) weakSelf = self;
staticSelf_ = weakSelf;
}
- (void)dealloc{
NSLog(@"dealloc走你");
}
请问这里运行效果是什么，会不会产生循环引用？
分析结果：这里肯定会产生循环引用，weakSelf->self，staticSelf->weakSelf，staticSelf是个全局静态变量，不会自动释放，所以这里产生了循环引用。
我们来运行下，如图
这里发现dealloc没有调用，所以产生循环引用了。
这里的weakSelf其实就是Self,我们断点打印一下，如图
这里可以看出，self、weakSelf、"staticSelf_"是指向同一块内存区域，也就是说weakSelf与self是映射关系，他们三个又构成了循环链，所以就产生了循环引用。
我们接着再分析一代码，如下
- (void)block_weak_strong {
__weak typeof(self) weakSelf = self;
self.doWork = ^{
__strong typeof(self) strongSelf = weakSelf;
weakSelf.doStudent = ^{
NSLog(@"111111111----- %@", strongSelf);
};
weakSelf.doStudent();
};
self.doWork();
}
请问这段代码的是否会产生循环引用？
答案是肯定会产生循环引用。
我们运行一，先看下结果，如图
上图已经说明了问题，会产生循环引用，究竟是为什么，我们来看下。
- self.doWork对self持有
- __strong typeof(self) strongSelf = weakSelf;
weakSelf.doStudent = ^{
NSLog(@"111111111----- %@", strongSelf);
};
weakSelf.doStudent();这里strongSelf对weakSelf持有，strongSelf虽然是临时变量，但是它的生命周期是在doWork这个block中，在strongSelf释放前，会执行上述代码，doStudent是会对strongSelf进行持有，捕获进去，对strongSelf引用计数+1操作，也就是说strongSelf的引用计数是2了，虽然在doWork这个block结束时会-1操作，但是还是无法释放这个strongSelf - 我们可以在NSLog(@"111111111----- %@", strongSelf);代码下面加入strongSelf=nil,断开循环链来解决。
结语
这篇文章结合实际应用讲述的Block的类型，循环引用的产生，以及如何解决这些问题，如有疑问，大家可以相互交流学习。