Block简介
Block的使用
1.Block属性
@property (nonatomic, copy) void(^block)(void);
通常我们用copy来修饰Block属性，其实在ARC下系统已经自动将Block拷贝到堆中，所以用strong和copy效果相同。但便于统一，所以copy修饰Block的习惯就保留下来了。
2.方法中Block参数
- (void)action:(void(^)(void)) {
}
Block是能够自动捕获外界变量的匿名函数，也是一个对象
在iOS中，对象和类对象都是结构体，首地址是isa指针，而Block本身也是结构体，所以首地址是isa指针的Block就是一个对象类型，原因在下方“__block原理”。
Block循环引用的经典例子
Block循环引用的经典例子
解决循环引用问题
循环引用的主要原因是 self -> block -> self 的持有方式，导致self无法释放，破解的办法就是打破这个持有方式，增加中间量。
// 循环引用的解决办法
@property (nonatomic, strong) NSString *name;
@property (nonatomic, copy) void(^block)(void);
// 1. weak strong dance
self.name = @"test";
__weak typeof(self) weakSelf = self;
self.block = ^{
// 使用__strong的原因是如果self被释放了，那么打印的是null
// 持有链是self -> block -> strongSelf -> self，strongSelf是局部变量，会被释放，所以可以打破循环
__strong typeof(self) strongSelf = weakSelf;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", strongSelf.name);
});
};
// 2. 使用中间变量
__block ViewController *vc = self;
self.block = ^{
// 持有链是self -> block -> vc -> self，vc是外部变量，手动释放后也可打破循环
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", strongSelf.name);
vc = nil;
});
};
// 3.将需要引用的数据当做Block参数，传入到代码块中
@property (nonatomic, copy) void(^block)(ViewController *vc);
self.block = ^(ViewController *vc) {
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"%@", vc.name);
});
};
Block在内存中的位置常用的有3种
Block在内存中的位置
Block普遍根据操作数据的分区来决定自己的位置，防止跨区操作消耗性能。
如果外部变量不用__block修饰，为什么在Block内部不可以修改该变量
1.我们先看下面的代码
__block int a = 10;
NSLog(@"操作前:%p", &a);
void(^block)(void) = ^{
a ++;
NSLog(@"操作中:%p", &a);
};
block();
NSLog(@"操作后:%p", &a);
打印结果如下
__block修饰变量的内存变化
由此我们可以得到一个暂时的结论：数据从栈拷贝到了堆区。
但这个结论是否正确，我们还要进一步验证。
为了验证我们刚刚的结论，我们进行底层编译。
在Terminal中创建一个.c文件，写入如下代码：
#include "stdio.h"
int main() {
void(^block)(void) = ^{
printf("block\n");
};
block();
return 0;
}
使用gcc进行编译得到的a.out，再执行a.out，打印出block，
再使用clang -rewrite-objc blockTest.c -o blockCPP.cpp，得到并打开C++文件：
// 其中有个__main_block_impl_0，我们搜索一下，找到对应的结构体
// 其中__block_impl就是Block的结构体
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// fp就是Block代码块的实现指针
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
// 根据impl.isa，可以得出Block是一个对象(源码中的NSObject协议里面有一个isa)。
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp; // 将fp赋值给属性函数进行保存
Desc = desc;
}
};
// Block代码块的底层函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("block - %d", a);
}
int main() {
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
// 简化为下方
// 为什么要调用Block的原因也清楚了，第一步只是定义了Block，将fp赋值给funcPtr，但并没有调用方法
id block = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
block->FuncPtr(block);
}
由此我们可以得到一些结论：Block中自定义的代码块本质也是一个函数，创建Block时将该函数指针保存在Block结构体中。
2.接着我们重新编译blockTest.c，将代码改为下方：
#include "stdio.h"
int main() {
int a = 10;
void(^block)(void) = ^{
printf("block - %d\n", a);
};
block();
return 0;
}
clang之后的C++代码如下：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// 多了一个变量a
int a;
/// 构造函数也多了一个参数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
// Block的内部代码，其实就是将结构体中的变量a赋值给一个局部变量a
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
printf("block - %d", a);
}
int main() {
int a = 10;
// 创建Block时，将a赋值到Block结构体中
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
}
我们可以看到，Block结构体中多了一个int类型的变量a，并且构造函数也多了一个参数，这其实就是Block自动捕获了外部变量a，将a赋值到结构体中进行保存。
我们无法修改变量的原因也了解到了：Block代码块中我们使用的是局部变量，所以无法修改原变量的值。
3.接下来我们将.c文件中的代码修改为：
#include "stdio.h"
int main() {
__block int a = 10;
void(^block)(void) = ^{
a ++;
printf("block - %d\n", a);
};
block();
return 0;
}
clang之后获得的C++代码为：
// 多了一个结构体a，里面保存的是a的值和地址
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
// 变量a变成了结构体a
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
// 修改的是结构体中的a的值
__Block_byref_a_0 *a = __cself->a; // bound by ref
(a->__forwarding->a) ++;
printf("block - %d", (a->__forwarding->a));
}
int main() {
// __block的本质就是创建一个结构体，将变量a的值和原来的地址保存到结构体中
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 10};
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return 0;
// 简化如下
__Block_byref_a_0 a = {
(void*)0,
(__Block_byref_a_0 *)&a,
0,
sizeof(__Block_byref_a_0),
10};
void(*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344);
block->FuncPtr(block);
}
所以我们得到的暂时结论：“数据从栈拷贝到堆上”是不准确的。
总结：
1.Block是一个对象，底层是一个结构体，保存自定义代码的函数指针
2.未使用__block情况下捕获到外部变量a时，将外部变量a赋值到Block结构体中的变量进行保存，自定义代码中调用时使用的是新创建局部变量a1，所以无法修改外部变量a的值。
3.__block的本质是创建一个结构体也是对象as，所以我们之前打印的地址是堆的地址。as中保存了变量a的地址和值，自定义代码中修改的就是结构体as中a的值。
网友评论