本文主讲Block相关面试问题，包括Block介绍、截获变量、__block修饰符、Block的内存管理、Block的循环引用。
一、Block介绍
定义:
Block是将函数及其执行上下文封装起来的对象。
Block本质:
源码解析:使用 clang -rewrite-objc file.m 查看编译之后的文件内容。
Block调用:
Block调用就是函数的调用。
二、截获变量。
被截获变量类型
被截获变量类型: 包括局部变量(基本数据类型和对象类型)、静态局部变量、全部变量、静态全部变量。
问题:关于Block截获变量的特性，是否有理解？
答: 对不同的数据类型，截获方式各有不同
1.对于基本数据类型的局部变量截获其值
2.对于对象类型的局部变量连同所有权修饰符一起截获
3.以指针方式截获静态局部变量
4.不截获全局变量、静态全局变量
源码解析:使用 clang -rewrite-objc -fobjc-arc file.m 查看编译之后的文件内容。
//面试题
int multiplier = 6;
int(^Block)(int) = ^int(int num){
return num*multiplier;
};
multiplier = 4;
NSLog(@"result is %d",Block(2)); //输出结果 -->result is 12
三、__block修饰符
一般情况下，对被截获变量进行赋值操作需添加__block修饰符。
注意：赋值不等于使用。
笔试题的坑:
NSMutableArray *array =[NSMutableArray array];
void(^Block)(void) = ^{
[array addObject:@"123"];
};
Block(); //该array为使用，只有赋值操作才需要__block 。
NSMutableArray *array2 =nil;
void(^Block2)(void) = ^{
array2 = [NSMutableArray array];
};
Block2(); //该block为赋值，存在问题，会编译报错，需要用__block修饰被截获变量array2。
问题:在什么场景下使用__block修饰符呢？
- 对截获变量进行赋值操作需要添加__block修饰符（赋值 != 使用）
- 对局部变量（基本数据类型和对象类型）进行赋值需要__block修饰符
- 对静态局部变量、全局变量、静态全局变量不需要__block修饰符
__block 面试题
{
__block int multiplier = 6;
int(^Block)(int) = ^int(int num){
return num*multiplier;
};
multiplier = 4;
NSLog(@"result is %d",Block(2)); //输出结果 -->result is 8
}
问题:__block修饰符起到了什么作用？__block的机制是什么？
答: __block修饰变量变成了对象
栈上的__block变量的__forwarding指针是指向其自身的
四、Block的内存管理
1、Block类型
Block类型：NSGlobalBlock、NSStackBlock、NSMallocBlock。
impl.isa = &_NSConcreteStackBlock;
2、Block的copy操作
问题: 三种类型的block进行copy有什么效果?
答:
- 对于数据区的block进行copy操作，什么也不做
- 对于栈区的block进行copy操作，在堆区产生block
- 对于堆区的block进行copy操作，会增加引用计数
3、生命周期
栈上Block的销毁
- 对于栈区的block，变量作用域结束，随之销毁
栈上Block的copy
问题:如果对栈上block进行copy 操作后, MRC环境下,是否会引起内存泄漏?
答: 会引起内存泄漏. 栈上block在变量作用域结束后会销毁, 堆上block没有其他成员变量指向它, 这和alloc 出一个对象最后没有release效果是一样的, 会引起内存泄漏.
栈上__block变量的copy
- 如果对
栈上的__block变量没有进行copy操作,__forwarding指针指向其自身, 同样上边一行代码,修改的是栈上的__block变量 - 对
栈上的__block变量进行copy操作后, 实际在堆上面也会产生一个__block变量,内容完全一样,但是是两块不同内存控件.栈上__block变量的__forwarding指针指向是堆上的__block变量,堆上__block变量的__forwarding指针指向其自身.
所以在对multiplier 整型值进行改变时 ,使用是转换出来的都是同一行代码 .
面试题:
{
__block int multiplier = 10;
_blk = ^int(int num){
return num * multiplier;
}
multiplier = 6;
[self excuteBlock];
}
- (void)excuteBlock{
int result = _blk(4);
NSLog(@"result is %d", result); // result is 24
}
4、__forwarding存在的意义
- 不管在任何内存位置，都可以顺利的访问同一个__block变量
五、Block的循环引用
Block循环引用（为什么会产生循环引用）在下图中，有什么问题？如何解决？
//_strBlk _array 都为当前对象的成员变量
// _array 由strong修饰, _strBlk 由copy 修饰
{
_array = [NSMutableArray arrayWithObject:@"block"];
_strBlk = ^NSString* (NSString *num){
return [NSString stringWithFormat:@"helloc_%@", _array[0]];
};
_strBlk(@"hello");
}
//产生自循环循环引用
产生自循环引用 :
因为当前对象通过copy声明block，而在当前block中又使用到了当前对象的成员变量，因为会连带属性关键字一起截获，因为array是通过strong修饰，因此block中有一个strong类型的指针指向当前对象，产生循环引用
解决方法：
避免循环引用——在当前栈中用__weak修饰的weakArray指针指向原对象的_array,在block中使用weakArray（因为截获的是一个__weak类型）
//解决
{
_array = [NSMutableArray arrayWithObject:@"block"];
__weak NSArray *weakArray = _array;
_strBlk = ^NSString* (NSString *num){
return [NSString stringWithFormat:@"helloc_%@", weakArray[0]];
};
_strBlk(@"hello");
}
问题:block外部 为什么通过__weak属性关键字修饰对象,就可以避免循环引用?
答:由于block截获变量是对象类型,会连同其所有权修饰符一起截获,在block外部定义变量是__weak所有权修饰符,在block所产生结构体中所持有的变量也是__weak的
问题: （__block造成的循环引用）在下代码中，有什么问题？如何解决？
{
__block MCBlock *blockSelf = self;
_blk = ^int(int num){
//var = 2
return num * blockSelf.var;
};
_blk(3);
}
答:
- 在MRC中，不会产生循环引用
- 在ARC中，产生循环引用，引起内存泄漏
解决:
{
__block MCBlock *blockSelf = self;
_blk = ^int(int num){
//var = 2
int result = num * blockSelf.var
blockSelf = nil;
return result;
};
_blk(3);
}
Block面试总结
问题: 什么是block？
答:Block是将函数及其执行上下文封装起来的对象。
问题: 为什么Block会产生循环引用？
答:
1>如果当前Block对当前对象的某一成员变量进行截获, block会对成员变量有强引用, 当前对象又对当前block有一个copy强引用, 就产生自循环引用问题.
可以通过声明对象的成员变量为 __weak 变量,来进行循环引用消除.
(因为当前对象通过copy声明block，而在当前block中又使用到了当前对象的成员变量，因为会连带属性关键字一起截获，如果成员变量使用strong修饰，因此block中有一个strong类型的指针指向当前对象，产生自循环引用.)
2>如果定义__block说明符 ,在ARC中 会产生循环引用, 在MRC中不会产生循环引用.
可以在ARC中采取断环的方式解决循环引用,但是有个弊端,如果block 如果一直没有调用, 循环引用是没有办法消除的.
问题:怎样理解Block截获变量的特性？
答:(被截获类型的分类回答)
答: 对不同的数据类型，截获方式各有不同
1.对于基本数据类型的局部变量对其值进行截获
2.对于对象类型的局部变量连同所有权修饰符一起截获
3.对于静态局部变量以指针方式截获
4.对于全局变量、静态全局变量不截获.
问题: 你都遇见过哪些循环引用？你又是咋样解决的
答:
NSTimer循环引用.
Block循环引用:2方面
1>block所捕获变量也是当前对象的成员变量, block 也是当前对象的成员变量,就会造成自循环引用. 采用避免循环引用方式, 加__weak所有权修饰符,来避免循环引用.
2>__block也会造成循环引用, 在ARC中 会产生循环引用, 在MRC中不会产生循环引用.
可以在ARC中采取断环的方式解决循环引用,但是有个弊端,如果block 如果一直没有调用, 循环引用是没有办法消除的.
1、相互循环引用
typedef void(^Block)(NSString*);
@interface ClassA()
{
int age;
}
@property(nonatomic,strong)Block block;
@property(nonatomic,strong)NSString *temp;
@end
@implementation ClassA
- (void)viewDidLoad {
[super viewDidLoad];
self.block = ^(NSString * content) {
self.temp = content;
self->age = 15;
};
}
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
self.block(@"赵四");
}
(1)、如上代码，self持有block，而堆上的block又会持有self，所以会导致循环引用，这个例子非常好，因为xcode都能检测出来，报出警告：[capturing self strongly in this block is likely to lead to a retain cycle]，当然大部分循环引用的情况xcode是不会报警告的。
(2)、这时Block对象虽然捕获了weakSelf，延长了weakSelf这个局部变量的生命周期，但weakSelf是附有__weak修饰符的变量，它并不会持有对象，一旦它指向的对象被废弃了，它将自动被赋值为nil。在多线程情况下，可能weakSelf指向的对象会在Block执行前被废弃，这样可能顶多就是返回nil，但在有些情况下（譬如在Block中有移除KVO的观察者的逻辑，在执行到该逻辑前self就释放了）就会导致crash。这时可以在Block内部（第一句）再持有一次weakSelf指向的对象，保证在执行Block期间该对象不会被废弃，这就是所谓的 weak-strong。
解决这种循环引用的常用方式如下
typedef void(^Block)(NSString*);
@interface ClassA()
{
int age;
}
@property(nonatomic,strong)Block block;
@property(nonatomic,strong)NSString *temp;
@end
@implementation ClassA
- (void)viewDidLoad {
[super viewDidLoad];
__weak typeof(self) weakSelf = self;
self.block = ^(NSString * content) {
__strong typeof(weakSelf)strongSelf = weakSelf;
strongSelf.temp = content;
strongSelf->age = 15;
};
}
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
self.block(@"赵四");
}
2、多循环引用
typedef void(^Block)(NSString*);
@interface ClassB : UIViewController
@property(nonatomic,strong)Block block;
#import "ClassA.h"
#import "ClassB.h"
@interface ClassA()
@property(nonatomic,strong)ClassB *classB;
@property(nonatomic,strong)NSString *temp;
@end
@implementation ClassA
- (void)viewDidLoad {
[super viewDidLoad];
self.classB = [[ClassB alloc]init];
self.classB.block = ^(NSString *content) {
self.temp = content;
};
}
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
self.classB.block(@"赵四");
}
@end
如上代码，ClassA持有ClassB，ClassB持有block，而堆上的block又会持有ClassA，所以会导致循环引用。
