iOS - Blocks
1. 什么是Blocks
Blocks是C语言的扩充功能。就是:带有自动变量的匿名函数。
类似C语言的函数指针。但Blocks不是一个指针,而是一个不带名字的函数,它允许开发者在两个对象之间将任意的语句当作数据进行传递,同时它又能获得上下文的信息(闭包Closure),所以在一些场合使用Blocks很方便简洁。
2. Block语法
我们先来看一个例子吧。
^int(int count){return count++;}
这个Block非常简单,就是把计数器加一,但麻雀虽小,五脏俱全,语法上一个元素都没漏掉。首先是^符号(插入符号caret),然后依次是是返回值类型,参数列表,表达式。
^ int (int count) {return count++;}
caret 返回参数 参数列表 表达式
齐全的Block就是这些内容了,不同的Block的表达式的复杂程度各异,但元素就是这么多了。
不过很多时候我们会遇到没有返回参数,或者没有传入参数,甚至既没有传入参数也没有返回参数的情况。这个时候Block可以省略相关的内容,就是说相对应的那一块不用写了。比如:
没有返回参数,可能就会写成:^(int count){printf("count=%d", count);}
没有参数列表,可能会写成:^int{return 1;}
既没有返回参数也没有参数列表,可能就会写成:^{printf("Blocks Demo!\n")};
Block还可以申明变量,Block变量一样可以用typedef来定义成新的类型,这种做法下和函数指针真的非常非常类似,仅仅是将*换成了^。举个例子:
int (^blk)(int) = ^int (int count) {return count+;};
熟悉C语言的人对这个都会比较熟悉。这里有一个要说明,上面的赋值语句右侧可以省略掉返回类型(猜测是这部分信息编译器已经可以确定,所以不再是必须提供的了)。这样,上面的语句也可以写成;
int (^blk)(int) = ^(int count) {return count+;};
如果使用typedef,就可以更清晰一点:
typedef int (^blk_t)(int);
blk_t blk = ^(int count) {return count+;};
3. 截获自动变量值
Block是带自动变量的匿名函数,下面就要看看“自动变量”了。Block可以访问在它之前申明的变量,但也有它特殊的地方,先看一个例子:
- int val = 1;
- void (^blk)(void) = ^{printf("val=%d\n", val);};
- val = 2;
- blk(); Block在定义时相当于对val这个变量照了张相,
- return 0;
运行结果val=1。请注意,虽然这个时候val的值已经变成了2,但Block里面仍然是1,也就是说,Block在定义时相当于对val这个变量照了张相,然后一直自己使用这张相片,不管val本身何去何从。
这个特性可以带来很大的便利(记下了定义时的上下文),有时是我们所需要的;但一不小心也很容易错,所以使用时需要注意。Block里面,val就是只读的,而且值是定义时的那个。
虽然记住上下文,Block的内容也跟随改变或者要修改自动变量的值,这个就需要用到__block关键词了。继续上代码:
- __block int val = 1;
- void (^blk)(void) = ^{printf("val=%d\n", val);};
- val = 2;
- blk();
- return 0;
- }
这段代码和上一段的区别仅仅是多了__block的声明,但运行结果就是val=2了,也就是说,Block能跟踪val的变化了。
这时,Block里面也可以改变val的值了,就是说,用了__block之后,val对于Block不再是只读的了,而是和自己定义的变量一样了。
在一个Block里面,往往两种变量都需要有,具体怎么使用,就看具体的情况了。
4. Block的使用
我总是觉得任何一种技术的出现总是用来解决某个问题的,也决定了在何种情况下使用该技术。Block应该如何使用呢?这是仁者见仁,智者见智的问题了,我接触最多的是在GCD里面。
个人的感觉这个东东主要用在回调里面,比如:网络连接成功后我应该把某个按钮激活之类的,Block使用起来简洁明快,如鱼得水。GCD实际上也是给出了系统的回调,所以就特别适合Block大显身手。
5. 其他
Block当然还有其他的一些内容,比如可以作为函数参数来传递,比如当自动变量是ObjC的对象时,虽然不能修改,但可以调用对象的方法,再比如,C语言的数组不能作为自动变量等等。但这些都不是Block主要的内容,最重要的还是灵活的使用。
从iOS4开始,苹果引入了这个C语言的扩充功能“Blocks”,在一些特定的场景下也是一把利刃。我前面一篇博客中初步介绍了Blocks这个东西,主要是语法的介绍(《iOS中Blocks的介绍》)。
我曾经看见了老外的一个系列的Blocks介绍,很有深度(A look inside blocks:Episode 1,A look inside blocks:Episode 2, A look inside blocks:Episode 3),里面深入到汇编的层次对Blocks的实现进行了分析。不过如果象我这样对于汇编不熟悉的人肯定也是很多的,理解起来十分痛苦,于是就想到从ObjC本身对Blocks进行的处理里面来入手分析,看看对于Blocks都悄悄做了什么。
2.环境
很简单,就是Xcode啦。使用的编译器是CLang,主要是利用了-rewrite-objc这个参数,把源文件转换成中间文件。这样就揭开了面纱的一角。我使用的clang编译器版本是:
Apple clang version 4.0 (tags/Apple/clang-421.0.60) (based on LLVM 3.1svn)
Target: x86_64-apple-darwin12.5.0
Thread model: posix
转成中间文件的命令是:clang -rewrite-objc 源文件
3. 例子1
- #include <stdio.h>
- int main(int argc, const charchar * argv[])
- {
- int val = 2;
- int val1 = 5;
- void (^blk)(void) = ^{printf("in Block():val=%d\n", val);};
- val = 4;
- blk();
- printf("in main(): val=%d, val1=%d\n", val, val1);
- return 0;
- }
代码的运行结果是:
in Block():val=2
in main():val=4, val1=5
这里我们可以看到Block对于自动变量的“快照”功能。由于转成中间文件之后发现长了很多,变成了100多行(不同的clang版本转换出来的文件还不同,不过实现部分代码还是一样的),下面的代码是相关部分的节选,主要说明苹果是如何实现的。
- struct __block_impl {
- voidvoid *isa;
- int Flags;
- int Reserved;
- voidvoid *FuncPtr;
- };
- #include <stdio.h>
- int main(int, const charchar **);
- struct __main_block_impl_0 {
- struct __block_impl impl;
- struct __main_block_desc_0* Desc;
- int val;
- __main_block_impl_0(voidvoid *fp, struct __main_block_desc_0 *desc, int _val, int flags=0) : val(_val) {
- impl.isa = &_NSConcreteStackBlock;
- impl.Flags = flags;
- impl.FuncPtr = fp;
- Desc = desc;
- }
- };
- static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
- int val = __cself->val; // bound by copy
- printf("in Block():val=%d\n", val);}
- static struct __main_block_desc_0 {
- unsigned long reserved;
- unsigned long Block_size;
- } __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
- int main(int argc, const charchar * argv[])
- {
- int val = 2;
- int val1 = 5;
- void (*blk)(void) = (void (*)(void))&__main_block_impl_0((voidvoid *)__main_block_func_0, &__main_block_desc_0_DATA, val);
- val = 4;
- ((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk);
- printf("in main(): val=%d, val1=%d\n", val, val1);
- return 0;
- }
中间文件确实看起来复杂了不少,不过还是有脉络可循。
看main函数的内容,里面有个函数指针blk,这个就是指向Block的指针,所以难怪Block变量的声明和函数指针如此相像(就是把*换成^),编译器转换后就是同一个东西啊。
我们看blk这个函数指针,就是__main_block_impl_0这个结构体变量的指针,这个结构体变量此时已经存在,然后用__main_block_func_0等几个变量赋初值。我们可以看到__main_block_impl_0这个struct中有个val这个项,并且在这里也赋值了,这就是给变量照的“快照”,由于这个变量在这里被记录了,所以无论外面的val变量如何变化,Block运行时使用的值就始终是“快照”的值了。同时我们也注意到__main_block_impl_0这个struct中没有val1这个项,所以说明如果Block中不用到的自动变量是不会自动加入到结构体中的。
Block的运行就是运行__main_block_impl_0这个struct中的FuncPtr这个指针,这个在前面初始化的时候已经被赋值成__main_block_func_0了,所以这里也就是运行这个函数,并把自己的指针传入。这里我们的实现非常简单,就是一句printf语句。
4.例子2
- #include <stdio.h>
- int main(int argc, const charchar * argv[])
- {
- int __block val = 2;
- int val1 = 5;
- void (^blk)(void) = ^{printf("in Block():val=%d\n", ++val);};
- blk();
- printf("in main(): val=%d, val1=%d\n", val, val1);
- return 0;
- }
这个例子把自动变量val声明成了__block变量,这样语法上Block不是对val进行“快照”,而是会直接使用val变量,同时在Block内部val可读可写,不再是只读的了。
运行结果如下:
in Block():val=3
in main(): val=3, val1=5
同样展开成中间文件来看苹果的实现。
- struct __block_impl {
- voidvoid *isa;
- int Flags;
- int Reserved;
- voidvoid *FuncPtr;
- };
- #include <stdio.h>
- int main(int, const charchar **);
- struct __Block_byref_val_0 {
- voidvoid *__isa;
- __Block_byref_val_0 *__forwarding;
- int __flags;
- int __size;
- int val;
- };
- struct __main_block_impl_0 {
- struct __block_impl impl;
- struct __main_block_desc_0* Desc;
- __Block_byref_val_0 *val; // by ref
- __main_block_impl_0(voidvoid *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
- impl.isa = &_NSConcreteStackBlock;
- impl.Flags = flags;
- impl.FuncPtr = fp;
- Desc = desc;
- }
- };
- static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
- __Block_byref_val_0 *val = __cself->val; // bound by ref
- printf("in Block():val=%d\n", ++(val->__forwarding->val));}
- static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
- static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
- static struct __main_block_desc_0 {
- unsigned long reserved;
- unsigned long Block_size;
- void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
- void (*dispose)(struct __main_block_impl_0*);
- } __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
- int main(int argc, const charchar * argv[])
- {
- __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 2};
- int val1 = 5;
- void (*blk)(void) = (void (*)(void))&__main_block_impl_0((voidvoid *)__main_block_func_0, &__main_block_desc_0_DATA, (struct __Block_byref_val_0 *)&val, 570425344);
- ((void (*)(struct __block_impl *))((struct __block_impl *)blk)->FuncPtr)((struct __block_impl *)blk);
- printf("in main(): val=%d, val1=%d\n", (val.__forwarding->val), val1);
- return 0;
- }
中间文件又变长了一些,除去我们已经了解的部分,我们可以看到自动变量val不再是直接加入到__main_block_impl_0里面,而是又变成了一个__Block_byref_val_0的struct结构体的指针。
main函数里面对于val的赋值已经变成了对这样一个数据结构的赋值,第一句上就把2赋给了__Block_byref_val_0里面的val项,然后在blk这个指针初始化的时候,把__Block_byref_val_0的结构体变量指针传入__main_block_impl_0。此后所有对于自动变量val的操作都变成对val.__forwarding->val的操作。这样就解决了Block内外变量同时变化的问题(在操作同一块内存)。
这里还看见__Block_byref_val_0里面有个__forwarding项,这个项是指向自身的一根指针。在blk指针初始化的时候我们把这个指针的值传入了__main_block_impl_0。
在__main_block_desc_0里面,多出了两个函数指针,分别用于copy和dispose,这两个函数这里也是自动生成的。
5.总结
综合前面的例子来看,Block的实现还是借助了C语言的函数指针来实现了,对于普通的自动变量,在Block声明时会快照内容存储;对于__block变量,则是生成一个数据结构来存储,然后取代所有访问这个变量的地方。
事实上,因为Block运行时完全可能自动变量的生命周期已经结束,所以Block对于内存的管理是很复杂的,会把内容从栈上copy到堆上(这也是copy和dispose函数的作用)。所以Block虽然威力巨大,但使用时也需要遵循一定的规则。
iOS中Block介绍(二)内存管理与其他特性
我们在前一章介绍了block的用法,而正确使用block必须要求正确理解block的内存管理问题。这一章,我们只陈述结果而不追寻原因,我们将在下一章深入其原因。
一、block放在哪里
我们针对不同情况来讨论block的存放位置:
1.栈和堆
以下情况中的block位于堆中:
- void foo()
- {
- __block int i = 1024;
- int j = 1;
- void (^blk)(void);
- void (^blkInHeap)(void);
- blk = ^{ printf("%d, %d\n", i, j);};//blk在栈里
- blkInHeap = Block_copy(blk);//blkInHeap在堆里
- }
- - (void)fooBar
- {
- _oi = 1;
- OBJ1* oj = self;
- void (^oblk)(void) = ^{ printf("%d\n", oj.oi);};
- void (^oblkInHeap)(void) = [oblk copy];//oblkInHeap在堆中
- }
2.全局区
以下情况中的block位于全局区:
- static int(^maxIntBlock)(int, int) = ^(int a, int b){return a>b?a:b;};
- - (void)fooBar
- {
- int(^maxIntBlockCopied)(int, int) =[maxIntBlock copy];
- }
- void foo()
- {
- int(^maxIntBlockCopied)(int, int) = Block_copy(maxIntBlock);
- }
需要注意的是,这里复制过后的block依旧位于全局区,实际上,复制操作是直接返回了原block对象。
二、block引用的变量在哪里
1.全局区
全局区的变量存储位置与block无关:
- static int gVar = 0;
- //__block static int gMVar = 1;
- void foo()
- {
- static int stackVar = 0;
- // __block static int stackMVar = 0;
- }
注意:static变量是不允许添加__block标记的
2.堆栈
此时,你可能会问,当函数foo返回后,栈上的j已经回收,那么blkInHeap怎么能继续使用它?这是因为没有__block标记的变量,会被当做实参传入block的底层实现函数中,当block中的代码被执行时,j已经不是原来的j了,所谓物是人非就是这样吧~
另外,如果使用到变量j的所有block都没有被复制至heap,那么这个变量j也不会被复制至heap。
因此,即使将j++这一句放到blk()这句之前,这段代码执行后,控制台打印结果也是:1024, 1。而不是1024, 2
三、其他特性
1.复制的行为
对block调用复制,有以下几种情况:
1.对全局区的block调用copy,会返回原指针,并且这期间不处理任何东西(至少目前的内部实现是这样);
2.对栈上的block调用copy,每次会返回新复制到堆上的block的指针,同时,所有__block变量都会被复制至堆一份(多次拷贝,只会生成一份)。
3.对已经位于heap上的block,再次调用copy,只会增加block的引用计数。
为什么我们不讨论retian的行为?原因是并没有Block_retain()这样的函数,而且objc里面的retain消息发送给block对象后,其内部实现是什么都不做。
2.objc类中的block复制
objc类实例方法中的block如果被复制至heap,那么当前实例会被增加引用计数,当这个block被释放时,此实例会被减少引用计数。
但如果这个block没有使用当前实例的任何成员,那么当前实例不会被增加引用计数。这也是很自然的道理,我既然没有用到这个instance的任何东西,那么我干嘛要retian它?
我们要注意的一点是,我看到网上有很多人说block引起了实例与block之间的循环引用(retain-cycle),并且给出解决方案:不直接使用self而先将self赋值给一个临时变量,然后再使用这个临时变量。
但是,大家注意,我们一定要为这个临时变量增加__block标记(多谢第三篇文章回帖网友的提醒)。
这一章我们以结果导向的方式来说明了各种情况下,block的内存问题,下一章,我将剖析运行时库的源码,从根源阐述block的行为。也就是过程导向的方式了。
//Block
// '^'脱字符
//函数指针
int (*p)(int, int) = sum;
//调用函数
sum(3, 4);
p(2 ,4);
//声明一个Block变量
/*1*///int:返回值 ,后面两个int:参数类型
int (^block1) (int, int) = nil;
//block 变量存储的值,是block的实现部分
//实现部分返回值类型常省略
//参数变量名不能省略
//以';'结尾
block1 = ^(int a, int b){
return a + b;
};
//使用block1
int sum = block1(2, 4);
NSLog(@"%d",sum);
/*2*//////////////////////////////////
void (^block2)() = ^(){
NSLog(@"无参数 无返回值的 block2(); ");
};
block2();//调用
//3,求两个数最大值 block
int (^maxValue) (int x,int y) = ^(int a,int b){
return a > b ? a : b;
};
int max = maxValue(2,3);//调用
NSLog(@"最大值:%d",max);
//4, 将字符串转成数字的block
int (^numberFromString)(NSString *) = ^(NSString *str){
return [str intValue];
};
NSLog(@"%d",numberFromString(@"123"));//回调了 ^numberFromString 这个block
//5, 给可变数组排序的block
//5,1
NSComparator sortBlock = ^(id string1, id string2)
{
return [string1 compare:string2];
};
NSMutableArray *stringArray = [NSMutableArray arrayWithObjects:@"a", @"c", @"b", @"d",nil];
[stringArray sortedArrayUsingComparator:sortBlock];
NSLog(@"sortArray:%@", stringArray);
//5,2
[stringArray sortUsingComparator:^NSComparisonResult(id obj1,id obj2){
if ([obj1 intValue] > [obj2 intValue]) {
return NSOrderedDescending;
}
return NSOrderedSame;
}];
NSLog(@"--%@",stringArray);
//6, 取别名
typedef int (^SumBlock) (int,int);
SumBlock sumBlock1 = ^(int a,int b){
return a + b;
};
NSLog(@"%d",sumBlock1(7,8));
//7, 求阶乘 的block
int (^jiecheng)(int) = ^(int n){
int m = 1;
for (int i = 1; i <= n; i++) {
m *= i;
}
return m;
};
NSLog(@"阶乘:%d",jiecheng(3));
//8, block内部可以访问外部局部变量,但是不能修改,若要修改需加__block 修饰
__block int count = 2;
void (^sayHi)() = ^(){
count = 3;
NSLog(@"count 被修改成=%d",count);
};
sayHi();
//9,