问题:
- Block的原理、本质是什么?
- Block的分类?
- Block的捕获机制?
- Blcok内部的内存管理?
- __Block的作用?用什么注意点?
- Block的属性修饰词为什么是Copy?使用Block有什么注意点?
- 循环引用问题
Block的本质
Block本质是封装了函数和函数调用的OC对象。
Block底层实现:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
成员变量: impl
类型为__block_impl
struct __block_impl {
void *isa; //和OC对象一样有个isa指针
int Flags; // 当block被copy时,应该执行的操作
int Reserved; // 保留字段
void *FuncPtr; // 方法指针
};
成员变量: Desc
static struct __main_block_desc_0 {
size_t reserved; // 保留字段
size_t Block_size; // block 的大小
}
Block的分类
- NSGlobalBlock 保存子
数据段
- NSStackBlock 保存子
栈
- NSMallocBlock 保存子
堆
,NSStackBlockcopy
后得到,blcok引用计数加一。-
MRC
NSStackBlockcopy
后得到。 -
ARC
系统会根据情况自动调用copy
- blcok 被强引用。
-
GCD
内部的block调用。 - blcok 在方法中作为参数时。
- blcok 在方法中作为返回值时。
-
Block的捕获机制
Block的捕获机制,是因为block是封装的一个函数,在一个函数内部,调用另一个函数内部的变量,超出了变量的作用域,所以需要将变量捕获到blcok内部。
- 全局变量 :不捕获、全局都可以调用。
OC代码:
void(^block)(void);
int a = 10;
#import
int main(int argc, const char * argv[]) {
@autoreleasepool {
block = ^{
NSLog(@"a = %d",a);
};
block();
}
return 0;
}
clang编译后的C++文件:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_1366d6_mi_0,a);
}
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 argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
block = ((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
并没有捕获全局变量a
,因为block
内部可以随时访问全局变量a
。
- 局部变量 : 捕获、但是访问值的方式不同。
- 局部静态变量:
static
修饰的局部变量,内存保存在数据段
,作用域为整个app,在另一个函数内可以通过变量地址访问,使用变量,访问值的方式为引用传递
。
- 局部静态变量:
OC代码:
void(^block)(void);
#import
int main(int argc, const char * argv[]) {
@autoreleasepool {
static int a = 10;
block = ^{
NSLog(@"a = %d",a);
};
block();
}
return 0;
}
clang编译后的C++代码:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int *a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_ca9917_mi_0,(*a));
}
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 argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
static int a = 10;
block = ((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;
}
可以看出__main_block_impl_0
同样多出了个成员变量a
,但是此时成员变量a
的类型为指针类型
,也可以看出__main_block_func_0()
函数在构造结构体__main_block_func_0
时传入的参数是&a
,
所以blcok
同样捕获了局部静态变量a
的值,并保存到__main_block_impl_0
的成员变量a
上,只是成员变量a
的类型为指针,这是因为static
修饰后的局部变量a
虽然作用域不变,但生存期和全局变量相同,为整个程序,一旦超出局部变量a的作用域,尽管局部变量a的地址还存在,但不能提供变量名a去访问。
。为防止,block内部访问局部变量a
时,block不在局部变量a
的作用域,所以block内部捕获局部变量a
的地址,通过地址去访问局部变量a
。
- 局部自动变量:
auto
(默认省略) 修饰的局部变量。内存保存在栈
,作用域为函数内部,超出作用域自动销毁,无法通过变量地址访问,使用变量,需要将变量的值传递进另一个函数,访问值的方式为值传递
。
基本数据类型
OC代码如下:
void(^block)(void);
#import
int main(int argc, const char * argv[]) {
@autoreleasepool {
int a = 10;
block = ^{
NSLog(@"a = %d",a);
};
block();
}
return 0;
}
clang编译后的C++代码:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_8b3967_mi_0,a);
}
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 argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int a = 10;
block = ((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;
}
可以看出__main_block_impl_0
结构体内多了个成员变量int a
,且在构造函数__main_block_impl_0 ()
构造结构体__main_block_impl_0
是传了个参数 int _a
,且 : a(_a)
,_a
的值赋给了成员变量a
,在看函数__main_block_impl_0 ()
函数在构造结构体__main_block_func_0
时可以发现
参数_a
的值为局部变量a
,所以block
捕获了局部变量a
的值并保存到__main_block_impl_0
的成员变量a
上。
对象数据类型的捕获机制
OC代码:
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *p = [[Person alloc] init];
void(^block)(void) = ^{
NSLog(@"p = %@",p);
};
block();
NSLog(@"-----");
}
return 0;
}
clang编译后的C++代码:
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
Person *p;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, Person *_p, int flags=0) : p(_p) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
Person *p = __cself->p; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_277de0_mi_0,p);
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src{
_Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
static void __main_block_dispose_0(struct __main_block_impl_0*src){
_Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
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(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
Person *p = ((Person *(*)(id, SEL))(void *)objc_msgSend)((id)((Person *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("Person"), sel_registerName("alloc")), sel_registerName("init"));
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, p, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_1z_bw1zh_rj5rg3glg1bxmzmnzc0000gp_T_main_277de0_mi_1);
}
return 0;
}
可以看出此时的__main_block_impl_0
结构体内有成员变量Person *p
,局部变量 p
的值赋值给了成员变量p
。
注意:Block捕获的变量,基本数据类型:会随blcok的销毁,变量一同销毁。如果是OC对象类型,内存是如何管理的?
Block内部的内存管理
- 基本数据类型:会随blcok的销毁,变量一同销毁。
- 对象类型:
- blcok 底层
struct __main_block_desc_0* Desc;
结构体内生成
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)
和
void (*dispose)(struct __main_block_impl_0*)
方法 - 在Block调用copy时调用
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)
-
void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*)
内部调用
_Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/)
根据捕获的变量的指针修饰类型是否为强引用对其进行内存管理。
-
- 在blcok销毁时调用
void (*dispose)(struct __main_block_impl_0*)
-
void (*dispose)(struct __main_block_impl_0*)
内部调用
_Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/)
释放捕获的变量。
-
- blcok 底层
__block的作用
blcok捕获的变量
- 局部静态变量:
static
修饰的局部变量,内存保存在数据段
,作用域为整个app,可以随便修改。 - 局部自动变量:
auto
(默认省略) 修饰的局部变量。内存保存在栈
,作用域为函数内部,超出作用域自动销毁,不能访问,也不能修改。
那么如何修改局部自动变量呢?
__block
就是为了实现这一功能。
__block
会将修饰的变量封装成OC对象,对象内部保存和变量的变量名、类型
一样的变量,这样block捕获的就是封装后的OC对象的值,OC的值不能变,但是OC对象的变量,可以修改,我们在block外部和内部实际访问的事OC对象内的和和变量的变量名、类型
一样的变量。
__forwarding
指针为什么会如此改变?
当blcok 从栈上拷贝到堆上后,__block
变量也被拷贝到堆上。
但是我们要保证,blcok内部修改后的变量,block外部访问的变量值也一样,block
此时是在堆上,
__forwarding
指针指向自身(堆上的变量),blcok外部的变量在栈上指向堆上的变量,保证了变量一致。
__block
修饰的变量封装的OC对象内部保存的变量的内存管理同block
捕获的变量的内存管理一样,__block
修饰的变量封装的OC对象内部也有copy
、dispose
方法。
Block的属性修饰词为什么是Copy?使用Block有什么注意点?
主要是在MRC下,blcok默认捕获变量后是在栈上,使用copy
修饰后进行强引用拷贝到堆上,
ARC下使用strong
也是一样的,但是延续了MRC下的习惯,和提醒block是copy到堆上的,也就普遍使用copy
修饰。
注意点:循环引用问题
Block的循环引用问题
解决循环引用。
-
__weak
对象释放时block内部,对象会设置为nil。
-
__unsafe_unretained
unretained
不会进行retain
操作,但是指针存储的地址不变,会产生野指针。