1、
typedef void(^captureObjectBlock)(void);
captureObjectBlock testBlock;
- (void)viewDidLoad {
[super viewDidLoad];
[self captureObject];
testBlock();
}
- (void)captureObject {
int captureNum = 1;
testBlock = ^() {
NSLog(@"num = %d", captureNum);
};
captureNum = 2;
}
上面打印的是几?captureNum 出作用域之后是否别销毁?
打印结果:
num = 1
同样类型的实例
typedef void(^captureObjectBlock2)(NSObject *);
captureObjectBlock2 testBlock2;
- (void)viewDidLoad {
[super viewDidLoad];
[self captureObject2];
testBlock2([[NSObject alloc] init]);
testBlock2([[NSObject alloc] init]);
testBlock2([[NSObject alloc] init]);
}
- (void)captureObject2 {
NSMutableArray *mutArray = [[NSMutableArray alloc] init];
testBlock2 = ^(NSObject *obj) {
[mutArray addObject:obj];
NSLog(@"mutArray元素的个数:%ld", [mutArray count]);
};
}
打印的数组的个数是多少?
有人会回答:mutArray是captureObject方法的局部变量,mutArray指针 保存到栈上,那么当执行完captureObject方法后,出去了作用域mutArray变量就会被系统自动释放。
所以当执行captureBlk([[NSObject alloc] init]); 的时候,mutArray为nil,每次打印的为0。
这是错误的,实际为
mutArray元素的个数:1
mutArray元素的个数:2
mutArray元素的个数:3
那么如果把上面代码中的mutArray改为weak类型:
NSMutableArray __weak *mutArray = [[NSMutableArray alloc] init];
打印结果:
mutArray元素的个数:0
mutArray元素的个数:0
mutArray元素的个数:0
2、
__block int testNum = 10;
void (^block)(void) = ^() {
NSLog(@"读取局部变量:%d", testNum);
testNum = 1000;
};
testNum = 20;
block();
NSLog(@"block执行后的值:%d", testNum);
打印结果:
读取局部变量:20
block执行后的值:1000
本文会分析上面的代码中block底层 都做了哪些操作。
用过block的可以 直接忽略前面的语法部分。直接从第三部分看即可。
void (^blockName)(int arg1, int arg2);
中文翻译:返回值(^block变量名)(block的参数)
参数名称可以省略,也可以写成:
void (^blockName)(int, int);
^void(int arg1, int arg2) {
};
中文翻译:^返回类型(block的参数)
返回类型可以省略,也可以写成:
^(int arg1, int arg2) {};
声明定义和调用:
void (^blockName)(int, int) = ^(int arg1, int arg2) {
NSLog(@"arg1 + arg2 = %d", arg1 + arg2);
};
blockName(1,2);
block作为方法的参数:
- (void)viewDidLoad {
//2、没有参数
void (^blockName2)() = ^() {
NSLog(@"block2");
};
blockName2();
//3、block有返回值
int (^blockName3)(int) = ^(int n) {
return n * 2;
};
//4、block作为方法的参数
[self testBlock2:blockName3];
}
- (void)testBlock2:(int(^)(int))myBlock {
myBlock(10);
}
@interface ViewController () {
NSInteger num;
}
@implementation ViewController
- (void)viewDidLoad {
//1、block修改成员变量
void (^block1)() = ^(){
++num;
NSLog(@"调用成员变量: %ld", num);
};
block1();
}
// 打印结果:
调用成员变量: 0
如果想修改局部变量,要用__block来修饰。这个时候是引用传递。下面会聊下block的实现原理。
//2、调用局部变量,不用__block
NSInteger testNum2 = 10;
void (^block2)() = ^() {
//testNum = 1000; 这样是编译不通过的
NSLog(@"修改局部变量: %ld", testNum2);
};
testNum2 = 20;
block2();
NSLog(@"testNum最后的值: %ld", testNum2);
// 打印结果:
修改局部变量: 10
testNum最后的值: 20
//3、修改局部变量,要用__block
__block NSInteger testNum3 = 10;
void (^block3)() = ^() {
NSLog(@"读取局部变量: %ld", testNum3);
testNum3 = 1000;
NSLog(@"修改局部变量: %ld", testNum3);
};
testNum3 = 20;
block3();
testNum3 = 30;
NSLog(@"testNum最后的值: %ld", testNum3);
// 打印结果:
修改局部变量: 20
修改局部变量: 1000
testNum最后的值: 30
网上很多通过Clang(LLVM编译器)将OC的代码转换成C++源码,来进行分析的。但是这些转换的代码并不是block的源代码,只是用来理解用的过程代码。
新建一个testBlock.m文件。文件中代码为:
#import
int main() {
void (^blockname)() = ^{
printf("打印block函数");
};
blockname();
return 0;
}
cd 到testBlock.m文件所在的目录,执行clang命令:
clang -rewrite-objc testBlock.m
这时会在目录中出现.cpp文件,生成.cpp的核心代码主要在文件的底部
// __block_impl 是block的结构体
struct __block_impl {
void *isa; // isa指针,在OC中,任何对象都有isa指针
int Flags; // 按 bit 位表示一些 block 的附加信息,在 block copy 实现时就会使用
int Reserved; // 保留变量
void *FuncPtr; // 函数指针,指向 block 声明的方法
};
// __main_block_func_0 是block要执行的函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("打印block函数");
}
// __main_block_desc_0 是 block描述信息 的结构体
static struct __main_block_desc_0 {
size_t reserved; // 结构体信息保留字段
size_t Block_size; // 结构体大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
// __main_block_impl_0 是block的实现,也是 block 实现的入口
struct __main_block_impl_0 {
struct __block_impl impl; // impl 为block类型的变量,函数里对它的impl的isa、Flags、FuncPtr来进行赋值
struct __main_block_desc_0* Desc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock; // block的三种类型:_NSConcreteStackBlock、_NSConcreteGlobalBlock、_NSConcreteMallocBlock
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
int main() {
// 定义并初始化了block类型的变量
void (*blockname)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
// 调用block
((void (*)(__block_impl *))((__block_impl *)blockname)->FuncPtr)((__block_impl *)blockname);
return 0;
}
强调一下关键的部分:
// __block_impl 是block的结构体
struct __block_impl {
void *isa; // isa指针,在OC中,任何对象都有isa指针
int Flags; // 按 bit 位表示一些 block 的附加信息,在 block copy 实现时就会使用
int Reserved; // 保留变量
void *FuncPtr; // 函数指针,指向 block 声明的方法
};
isa:isa指针,在Objective-C中,任何对象都有isa指针。
block 有三种类型:
_NSConcreteGlobalBlock:全局的静态 block,类似函数。如果block里不获取任何外部变量。或者的变量是全局作用域时,如成员变量、属性等; 这个时候就是Global类型
_NSConcreteStackBlock:保存在栈中的 block,栈都是由系统管理内存,当函数返回时会被销毁。__block类型的变量也同样被销毁。为了不被销毁,block会将block和__block变量从栈拷贝到堆。
_NSConcreteMallocBlock:保存在堆中的 block,堆内存可以由开发人员来控制。当引用计数为 0 时会被销毁。
代码执行的时候,block的isa有上面3种值
impl.isa = &_NSConcreteStackBlock;
这里 impl.isa 的类型为_NSConcreteStackBlock,由于 clang 改写的具体实现方式和 LLVM 不太一样,所以这里 isa 指向的还是_NSConcreteStackBlock。但在 LLVM 的实现中,开启 ARC 时,block 应该是 _NSConcreteGlobalBlock 类型。
所以 block是什么类型 在 clang代码里是看不出来的。
如果要查看block的类型还是要通过Xcode进行打印:
- (void) clangCode {
void (^clangBlk)() = ^{
printf("打印block函数");
};
NSLog(@"clangBlk = %@", clangBlk);
clangBlk();
}
打印结果:
clangBlk = <__NSGlobalBlock__: 0x10ac58090>
打印block函数
上面block代码,没有获取任何外部变量,应该是 _NSConcreteGlobalBlock类型的。该类型的block和函数一样 存放在 代码段 内存段。内存管理简单。
新建testBlock2.m文件,代码如下:
#import
int main() {
int num = 1;
void (^blockname)() = ^{
printf("num = %d", num);
};
blockname();
return 0;
}
通过clang命令生成 的核心代码如下,和刚才clang的代码 不同的地方 已经加了注释:
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int num; // 1、多了一个变量 num,block访问的局部变量,赋值给了这个int变量
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _num, int flags=0) : num(_num) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int num = __cself->num; // 2、__main_block_impl_0 的 num 变量赋值给 __main_block_func_0 里的变量
printf("num = %d", num);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main() {
int num = 1; // 3、主函数内多了int变量
void (*blockname)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, num));
((void (*)(__block_impl *))((__block_impl *)blockname)->FuncPtr)((__block_impl *)blockname);
return 0;
}
关键部分:
_NSConcreteStackBlock类型的block存在栈区,当变量作用域结束的时候,这个block和block上的__block变量就会被销毁。
这样当block获取了局部变量,在其他地方访问的时候就会崩溃。block通过copy来解决了这个问题,可以将block从栈拷贝到堆。这样当栈上的作用域结束后,仍然可以访问block和block中的外部变量。
现在看文章开头的问题:
typedef void(^captureObjectBlock2)(NSObject *);
captureObjectBlock2 testBlock2;
- (void)viewDidLoad {
[super viewDidLoad];
[self captureObject2];
testBlock2([[NSObject alloc] init]);
testBlock2([[NSObject alloc] init]);
testBlock2([[NSObject alloc] init]);
}
- (void)captureObject2 {
NSMutableArray *mutArray = [[NSMutableArray alloc] init];
testBlock2 = ^(NSObject *obj) {
[mutArray addObject:obj];
NSLog(@"mutArray元素的个数:%ld", [mutArray count]);
};
}
为什么局部变量muArray出了作用域 还能存在?
captureBlk为默认的__strong类型,当block被赋值给__strong类型的对象或者block的成员变量时,编译器会自动调用block的copy方法。
执行copy方法,block拷贝到堆上,mutArray变量赋值给block的成员变量。所以打印的结果就为1,2,3。
如果把上面代码中的mutArray改为weak类型,那么打印的就都是0了。因为当出去作用域的时候,mutArray就已经被释放了。
同时,因为NSMutableArray *mutArray 是引用类型,用clang命令执行后,发现:
struct __main_block_impl_0
{
struct __block_impl impl;
struct __main_block_desc_0 *Desc;
id __strong mutArray;
.....
}
mutArray在block中是id类型,因为是指针 所以在block中mutArray是可以修改的,而int类型的不能修改。当然如果用__block也能修改int类型的外部变量
下面这个打印的结果是1,也是这个道理:
typedef void(^captureObjectBlock)(void);
captureObjectBlock testBlock;
- (void)viewDidLoad {
[super viewDidLoad];
[self captureObject];
testBlock();
}
- (void)captureObject {
int captureNum = 1;
testBlock = ^() {
NSLog(@"num = %d", captureNum);
};
captureNum = 2;
}
同时访问外部变量是block进行的值传递,所以打印的还是1,不是2。
[captureBlk2 copy];
@property (nonatomic, strong) captureObjBlk2 captureBlk21;
新建testBlock3.m,代码如下:
#import
int main() {
__block int num = 1;
void (^blockName)() = ^{
num = 10;
printf("num = %d", num);
};
blockName();
return 0;
}
用clang生成的代码如下,进行了详细的注释:
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
// 用于封装 __block 修饰的外部变量
struct __Block_byref_num_0 {
void *__isa; // 对象指针
__Block_byref_num_0 *__forwarding; // 指向 拷贝到堆上的 指针
int __flags; // 标志位变量
int __size; // 结构体大小
int num; // 外部变量
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_num_0 *num; // __block int num 变成了 __Block_byref_num_0 指针变量,也就是 __block 的变量通过指针传递给block
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__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_num_0 *num = __cself->num; // bound by ref
(num->__forwarding->num) = 10;
printf("num = %d", (num->__forwarding->num));
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
// _Block_object_assign 函数:当block从栈拷贝到堆时,调用此函数
_Block_object_assign((void*)&dst->num, (void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);
}
// __main_block_dispose_0 函数:当 block 从堆释放内存时,调用此函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t 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() {
__attribute__((__blocks__(byref))) __Block_byref_num_0 num = {(void*)0,(__Block_byref_num_0 *)&num, 0, sizeof(__Block_byref_num_0), 1};
void (*blockName)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_num_0 *)&num, 570425344));
((void (*)(__block_impl *))((__block_impl *)blockName)->FuncPtr)((__block_impl *)blockName);
return 0;
}
block访问的外部变量,在block中就是一个结构体:__Block_byref_num_0
// 一、用于封装 __block 修饰的外部变量
struct __Block_byref_num_0 {
void *__isa; // 对象指针
__Block_byref_num_0 *__forwarding; // 指向 拷贝到堆上的 指针
int __flags; // 标志位变量
int __size; // 结构体大小
int num; // 外部变量
};
为了对__Block_byref_num_0结构体进行内存管理。新加了copy和dispose函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
// _Block_object_assign 函数:当block从栈拷贝到堆时,调用此函数
_Block_object_assign((void*)&dst->num, (void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);
}
// __main_block_dispose_0 函数:当 block 从堆释放内存时,调用此函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->num, 8/*BLOCK_FIELD_IS_BYREF*/);
}
__main_block_impl_0 中增加了 __Block_byref_num_0类型的指针变量。所以__block的变量之所以可以修改 是因为 指针传递。所以block内部修改了值,外部也会改变
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_num_0 *num; // __block int num 变成了 __Block_byref_num_0 指针变量,也就是 __block 的变量通过指针传递给block
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_num_0 *_num, int flags=0) : num(_num->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
在block要执行的函数 __main_block_func_0中,我们通过__Block_byref_num_0的__forwarding指针来修改的 外部变量,即:(num->__forwarding->num) = 10;
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_num_0 *num = __cself->num; // bound by ref
(num->__forwarding->num) = 10; // 这里修改的是__forwarding 指向的内存的值
printf("num = %d", (num->__forwarding->num));
}
现在看看文章开头的第二个问题
__block int testNum = 10;
void (^block)(void) = ^() {
NSLog(@"读取局部变量:%d", testNum);
testNum = 1000;
};
testNum = 20;
block();
NSLog(@"block执行后的值:%d", testNum);
当外部的局部变量testNum改变后,block内的testNum变量也变了。
在block中修改的testNum值,在block外部testNum也改变了。
看下刚才clang生成的main方法
int main() {
__attribute__((__blocks__(byref))) __Block_byref_num_0 num = {(void*)0,(__Block_byref_num_0 *)&num, 0, sizeof(__Block_byref_num_0), 1};
void (*blockName)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_num_0 *)&num, 570425344));
((void (*)(__block_impl *))((__block_impl *)blockName)->FuncPtr)((__block_impl *)blockName);
return 0;
}
类似的逻辑:
用__block修改后,testNum变量转换为__Block_byref_num_0 的结构体。
上面说过copy操作会将block从栈拷贝到堆上, 会把 testNum转成的__Block_byref_num_0 结构体 赋值给block的变量。
同时 会把 __Block_byref_num_0 的结构体中的 __forwarding指针指向拷贝到堆上 结构体。
就是栈上和拷贝到堆上的 的__Block_byref_num_0都用__forwarding指向堆上的自己。
这样在栈上修改 testNum变量的时候,实际修改的是堆上值,所以block内外的值是相互影响