一、Block本质
Block本质上是一个OC对象，内部也有个isa指针
二、Block的底层源码
- 1、测试代码
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
//定义一个无参无返回值的block revanBlock
void(^revanBlock)(void) = ^{
NSLog(@"定义一个block");
};
//调用block
revanBlock();
}
@end
打印输出：
定义一个block
- 2、进入ViewController.m文件的目录下载命令行中执行一下命令转成C++代码
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc ViewController.m -o ViewController.cpp
-
3、ViewController.cpp¡
Block底层源码.png
- 4、经过简化后的代码
- 4.1、定义revanBlock
//定义revanBlock
void(*revanBlock)(void) =
&__ViewController__viewDidLoad_block_impl_0(
__ViewController__viewDidLoad_block_func_0,
&__ViewController__viewDidLoad_block_desc_0_DATA
);
- 4.2、调用block
//调用revanBlock
(revanBlock->FuncPtr)(revanBlock);
- 4.3、__ViewController__viewDidLoad_block_impl_0结构体
/**
1、__ViewController__viewDidLoad_block_impl_0：是一个结构体
2、C++中的结构体是可以存放函数
3、第一个元素：impl是一个struct __block_impl类型的结构体
struct __block_impl {
void *isa;//OC本质isa执行class对象
int Flags;
int Reserved;//保留字段
void *FuncPtr;//block代码地址
};
4、第二个元素：Desc是一个struct __ViewController__viewDidLoad_block_desc_0类型结构体指针
static struct __ViewController__viewDidLoad_block_desc_0 {
size_t reserved;//保留字段
size_t Block_size;//revanBlock的占用内存大小
}
5、C++中的构造函数（类似OC初始化方法）
5.1、第一个参数fp指针
5.2、第二个参数desc指针
5.3、第三个参数flags默认值为0
5.4、给结构体赋值
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
*/
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
//C++中的构造函数（类似OC初始化方法）
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
- 4.4、定义revanBlock时传入的第一个参数__ViewController__viewDidLoad_block_func_0是一个函数，所以从上面的分析可以知道，在定义block的时候把__ViewController__viewDidLoad_block_func_0这个函数当成参数fp指针传给了impl中的FuncPtr
static void __ViewController__viewDidLoad_block_func_0(struct __ViewController__viewDidLoad_block_impl_0 *__cself) {
NSLog((NSString *)&__NSConstantStringImpl__var_folders_ym_kg_kmbfn17v86dqrzyv26ww80000gn_T_ViewController_54ed6a_mi_0);
}
- 4.5、定义revanBlock时传入的第二个参数__ViewController__viewDidLoad_block_desc_0_DATA是一个函数
static struct __ViewController__viewDidLoad_block_desc_0 {
size_t reserved;
size_t Block_size;
} __ViewController__viewDidLoad_block_desc_0_DATA = { 0, sizeof(struct __ViewController__viewDidLoad_block_impl_0)};
- 5、调用revanBlock
//调用revanBlock
(revanBlock->FuncPtr)(revanBlock);
- 由定义revanBlock可知，revanBlock对象存储这__ViewController__viewDidLoad_block_impl_0的地址，又由于__ViewController__viewDidLoad_block_impl_0结构体中第一位元素是struct __block_impl类型的结构体impl，并且通过构造函数把传进来的fp指针赋值给了impl元素中的元素FuncPtr。
-
小结：block是封装了函数调用以及函数调用环境的OC对象
block底层结构.png
三、Block变量捕获
1、局部变量
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个局部变量
int var = 10;
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 22;
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
// 调用block
revanBlock();
}
@end
打印输出
2018-07-06 00:46:45.153676+0800 01-Block本质[7329:464430] block中使用var=10
- 为什么输出的age不是22？
- 1、此时revanBlock的底层源码
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
//多了一个var变量
int var;
//C++构造函数多了一个_var参数
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int _var, int flags=0) : var(_var) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
- 发现在这里捕获了block中使用的外界局部变量
2、使用static修饰的局部变量
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个局部变量
static int var = 10;
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
// 调用block
revanBlock();
}
@end
打印输出：
2018-07-06 01:00:10.983673+0800 01-Block本质[7514:473562] block中使用var=20
- 这次问什么输出的是20？
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
//var现在是一个int类型的指针
int *var;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int *_var, int flags=0) : var(_var) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
- 即使是使用static修饰的局部变量依然会被block捕获
3、全局变量
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
// 1、定义一个全局变量
int var = 10;
- (void)viewDidLoad {
[super viewDidLoad];
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
// 调用block
revanBlock();
}
@end
打印输出：
2018-07-06 01:05:36.830416+0800 01-Block本质[7579:478837] block中使用var=20
- block没有捕获全局变量
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
- 小结
- 如果block中使用局部变量，局部变量一定会被block捕获
-
如果block中使用全局变量，不会被block捕获
block的变量捕获.png
四、MRC下的Block的类型
1、block中不使用任何变量，Block为NSGlobalBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
revanBlock = ^{
NSLog(@"block中输出");
};
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
// 调用block
revanBlock();
NSLog(@"%@", [revanBlock class]);
[revanBlock release];
}
@end
打印输出：
2018-07-06 01:19:07.472305+0800 01-Block本质[7791:489628] block中输出
2018-07-06 01:19:07.472491+0800 01-Block本质[7791:489628] __NSGlobalBlock__
2、block中使用局部变量，block是NSStackBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个局部变量
int var = 10;
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
revanBlock();
NSLog(@"%@", [revanBlock class]);
[revanBlock release];
}
@end
打印输出：
2018-07-06 01:29:34.738826+0800 01-Block本质[7960:498531] block中使用var=10
2018-07-06 01:29:34.739160+0800 01-Block本质[7960:498531] __NSStackBlock__
3、block中使用static修饰的局部变量，block是NSGlobalBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个局部变量
static int var = 10;
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
revanBlock();
NSLog(@"%@", [revanBlock class]);
[revanBlock release];
}
@end
打印输出：
2018-07-06 01:31:44.566522+0800 01-Block本质[7989:500158] block中使用var=20
2018-07-06 01:31:44.566791+0800 01-Block本质[7989:500158] __NSGlobalBlock__
4、block中使用全局变量，block是NSGlobalBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
// 1、定义一个全局变量
static int var = 10;
- (void)viewDidLoad {
[super viewDidLoad];
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
revanBlock();
NSLog(@"%@", [revanBlock class]);
[revanBlock release];
}
@end
打印输出：
2018-07-06 01:34:44.150311+0800 01-Block本质[8041:502465] block中使用var=20
2018-07-06 01:34:44.150554+0800 01-Block本质[8041:502465] __NSGlobalBlock__
五、在ARC下的Block的类型
1、block中不使用任何变量，block是NSGlobalBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
revanBlock = ^{
NSLog(@"block中输出");
};
// 调用block
revanBlock();
NSLog(@"%@", [revanBlock class]);
}
@end
打印输出：
2018-07-06 01:39:14.251938+0800 01-Block本质[8119:505911] block中输出
2018-07-06 01:39:14.252169+0800 01-Block本质[8119:505911] __NSGlobalBlock__
2、block中使用局部变量，block是NSMallocBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个局部变量
int var = 10;
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
revanBlock();
NSLog(@"%@", [revanBlock class]);
}
@end
打印输出：
2018-07-06 01:40:46.853263+0800 01-Block本质[8147:507357] block中使用var=10
2018-07-06 01:40:46.853484+0800 01-Block本质[8147:507357] __NSMallocBlock__
3、block中使用static修饰的局部变量，block是NSGlobalBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个局部变量
static int var = 10;
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
revanBlock();
NSLog(@"%@", [revanBlock class]);
}
@end
打印输出：
2018-07-06 01:42:20.169110+0800 01-Block本质[8171:508554] block中使用var=20
2018-07-06 01:42:20.169337+0800 01-Block本质[8171:508554] __NSGlobalBlock__
4、block中使用全局变量，block是NSGlobalBlock类型
#import "ViewController.h"
@interface ViewController ()
@end
@implementation ViewController
void(^revanBlock)(void);
// 1、定义一个全局变量
int var = 10;
- (void)viewDidLoad {
[super viewDidLoad];
// 2、定义一个无参无返回值的block revanBlock
revanBlock = ^{
NSLog(@"block中使用var=%d", var);
};
// 3、重新给var赋值
var = 20;
revanBlock();
NSLog(@"%@", [revanBlock class]);
}
@end
打印输出：
2018-07-06 01:44:10.719455+0800 01-Block本质[8194:509956] block中使用var=20
2018-07-06 01:44:10.719677+0800 01-Block本质[8194:509956] __NSGlobalBlock__
- 小结
- block是基础NSBlock
- 当block中使用了局部变量(auto修饰)时，在MRC下block是NSStackBlock类型，在ARC下是NSMallockBlock类型
- 在其他情况下都是NSGlobalBlock类型
- 在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上
- block作为函数返回值时
- 将block赋值给__strong指针时
- block作为Cocoa API中的方法名含有usingBlock的方法参数时
-
block作为GCD API的方法参数时
block类型.png
block不同的类型内存分配.png
不同类型的block执行copy操作.png
六、Block访问对象类型
1、block中访问局部对象类型
- 1、RevanPerson
#import <Foundation/Foundation.h>
@interface RevanPerson : NSObject
@property (nonatomic, assign) int age;
@end
#import "RevanPerson.h"
@implementation RevanPerson
@end
- 2、测试代码
#import "ViewController.h"
#import "RevanPerson.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
// 1、定义一个RevanPerson对象
RevanPerson *revan_p = [[RevanPerson alloc] init];
revan_p.age = 20;
// 2、定义一个无参无返回值的block revanBlock
void (^revanBlock)(void) = ^{
NSLog(@"block中使用对象%@ 年龄为%d", revan_p, revan_p.age);
};
// 3、调用block
revanBlock();
}
@end
打印输出：
2018-07-07 17:42:43.844470+0800 01-Block本质[5511:325252] block中使用对象<RevanPerson: 0x6000000135a0> 年龄为20
- 从底层的数据结构窥探一下在block中使用对象和在block中使用基本数据类型变量有什么区别
-1、定义block
//定义block
void (*revanBlock)(void) = ((void (*)())&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, revan_p, 570425344));
- 2、__ViewController__viewDidLoad_block_impl_0结构体，依然会会把用到的局部对象变量捕获到结构体中
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
RevanPerson *__strong revan_p;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, RevanPerson *__strong _revan_p, int flags=0) : revan_p(_revan_p) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
- 3、struct __ViewController__viewDidLoad_block_desc_0结构体，与基本数据类型相比，多了copy函数和dispose函数
static struct __ViewController__viewDidLoad_block_desc_0 {
size_t reserved;
size_t Block_size;
//多了一个copy函数
void (*copy)(struct __ViewController__viewDidLoad_block_impl_0*, struct __ViewController__viewDidLoad_block_impl_0*);
//多了一个dispose函数
void (*dispose)(struct __ViewController__viewDidLoad_block_impl_0*);
}
- 4、__ViewController__viewDidLoad_block_desc_0_DATA函数
static struct __ViewController__viewDidLoad_block_desc_0 {
size_t reserved;
size_t Block_size;
//多了一个copy函数指针
void (*copy)(struct __ViewController__viewDidLoad_block_impl_0*, struct __ViewController__viewDidLoad_block_impl_0*);
//多了一个dispose函数指针
void (*dispose)(struct __ViewController__viewDidLoad_block_impl_0*);
} __ViewController__viewDidLoad_block_desc_0_DATA = {
0,
sizeof(struct __ViewController__viewDidLoad_block_impl_0),
__ViewController__viewDidLoad_block_copy_0,
__ViewController__viewDidLoad_block_dispose_0
};
把__ViewController__viewDidLoad_block_copy_0函数的地址赋值给copy
把__ViewController__viewDidLoad_block_dispose_0函数的地址赋值给dispose
- 4.1、__ViewController__viewDidLoad_block_copy_0函数中调用_Block_object_assign函数
static void __ViewController__viewDidLoad_block_copy_0(struct __ViewController__viewDidLoad_block_impl_0*dst, struct __ViewController__viewDidLoad_block_impl_0*src) {
//copy函数指针会调用_Block_object_assign函数
_Block_object_assign((void*)&dst->revan_p, (void*)src->revan_p, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
- 4.2、__ViewController__viewDidLoad_block_dispose_0函数调用_Block_object_dispose函数
static void __ViewController__viewDidLoad_block_dispose_0(struct __ViewController__viewDidLoad_block_impl_0*src) {
//dispose函数指针会调用_Block_object_dispose
_Block_object_dispose((void*)src->revan_p, 3/*BLOCK_FIELD_IS_OBJECT*/);
}
- 小结：在block中访问对象类型变量和访问基本数据类型变量的区别
- 相同点：block中都会捕获变量
- 不同点：block中使用对象时，会多2个函数指针（copy，dispose）
2、没有强指针指向的Block对象中引用对象变量
- 1、RevanPerson
#import <Foundation/Foundation.h>
@interface RevanPerson : NSObject
@end
#import "RevanPerson.h"
@implementation RevanPerson
- (void)dealloc {
NSLog(@"RevanPerson -dealloc");
}
@end
- 2、测试代码
#import "ViewController.h"
#import "RevanPerson.h"
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
{
// 定义一个RevanPerson对象
RevanPerson *revan_p = [[RevanPerson alloc] init];
//使用block
^{
NSLog(@"没有强指针的block对象中使用revan_p对象：%@", revan_p);
}();
NSLog(@"%@", [^{
NSLog(@"没有强指针的block对象中使用revan_p对象：%@", revan_p);
} class]);
}
NSLog(@"--- RevanPerson对象作用域之外 ---");
}
@end
打印输出：2018-07-07 19:32:37.465583+0800 01-Block本质[7527:406694] 没有强指针指向的block对象中使用revan_p对象：<RevanPerson: 0x60000000a630>
2018-07-07 19:32:37.465839+0800 01-Block本质[7527:406694] __NSStackBlock__
2018-07-07 19:32:37.465989+0800 01-Block本质[7527:406694] RevanPerson -dealloc
2018-07-07 19:32:37.466193+0800 01-Block本质[7527:406694] --- RevanPerson对象作用域之外 ---
- 小结：没有强指针指向的Block对象，并且在block中使用局部对象变量时，可以知道这个Block是一个NSStackBlock类型的，存储在栈区。所以当代码执行过作用域之外首先Block的栈内存会被系统回收，同时revan_p对象也没有强指针引用，所以revan_p对象也会被释放。
- 源码可知revan_p对象依然会被这个NSStackBlock类型的block捕获
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
RevanPerson *__strong revan_p;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, RevanPerson *__strong _revan_p, int flags=0) : revan_p(_revan_p) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
3、有强指针指向的Block对象中引用对象变量
- 1、RevanPerson
#import <Foundation/Foundation.h>
@interface RevanPerson : NSObject
@end
#import "RevanPerson.h"
@implementation RevanPerson
- (void)dealloc {
NSLog(@"RevanPerson -dealloc");
}
@end
- 测试代码
#import "ViewController.h"
#import "RevanPerson.h"
typedef void(^RevanBlock)(void);
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
RevanBlock revan_block;
{
// 定义一个RevanPerson对象
RevanPerson *revan_p = [[RevanPerson alloc] init];
//使用block
revan_block = ^{
NSLog(@"有强指针指向的block对象中使用revan_p对象：%@", revan_p);
};
NSLog(@"%@", [revan_block class]);
}
NSLog(@"--- RevanPerson对象作用域之外 ---");
revan_block();
}
@end
打印输出:
2018-07-07 19:46:07.460595+0800 01-Block本质[7749:417687] __NSMallocBlock__
2018-07-07 19:46:07.460891+0800 01-Block本质[7749:417687] --- RevanPerson对象作用域之外 ---
2018-07-07 19:46:07.461208+0800 01-Block本质[7749:417687] 有强指针指向的block对象中使用revan_p对象：<RevanPerson: 0x60400001ab30>
2018-07-07 19:46:07.461326+0800 01-Block本质[7749:417687] RevanPerson -dealloc
- 小结：revan_block是NSMallocBlock类型的Block，存储在堆中。从这次的打印输出可以看出RevanPerson在出作用并没有立即释放，而是等到 revan_block()调用之后， revan_block销毁了之后，RevanPerson对象随后销毁。
- 源码分析
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
RevanPerson *__strong revan_p;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, RevanPerson *__strong _revan_p, int flags=0) : revan_p(_revan_p) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
4、有强指针指向的Block对象中引用使用__week修饰的对象变量
- 1、RevanPerson
#import <Foundation/Foundation.h>
@interface RevanPerson : NSObject
@end
#import "RevanPerson.h"
@implementation RevanPerson
- (void)dealloc {
NSLog(@"RevanPerson -dealloc");
}
@end
- 2、测试代码
#import "ViewController.h"
#import "RevanPerson.h"
typedef void(^RevanBlock)(void);
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
RevanBlock revan_block;
{
// 定义一个RevanPerson对象
RevanPerson *revan_p = [[RevanPerson alloc] init];
__weak RevanPerson *weakRevan_p = revan_p;
//使用block
revan_block = ^{
NSLog(@"有强指针指向的block对象中使用weakRevan_p对象：%@", weakRevan_p);
};
NSLog(@"%@", [revan_block class]);
}
NSLog(@"--- RevanPerson对象作用域之外 ---");
revan_block();
}
@end
打印输出：
2018-07-07 19:52:19.223148+0800 01-Block本质[7853:421860] __NSMallocBlock__
2018-07-07 19:52:19.223364+0800 01-Block本质[7853:421860] RevanPerson -dealloc
2018-07-07 19:52:19.223496+0800 01-Block本质[7853:421860] --- RevanPerson对象作用域之外 ---
2018-07-07 19:52:19.223626+0800 01-Block本质[7853:421860] 有强指针指向的block对象中使用weakRevan_p对象：(null)
- 小结：revan_block这个Block依然是NSMallocBlock类型的Block，但是发现使用__weak修饰的对象weakRevan_p在作用域一过就立即释放。
- 源码分析
struct __ViewController__viewDidLoad_block_impl_0 {
struct __block_impl impl;
struct __ViewController__viewDidLoad_block_desc_0* Desc;
RevanPerson *__weak weakRevan_p;
__ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, RevanPerson *__weak _weakRevan_p, int flags=0) : weakRevan_p(_weakRevan_p) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
5、小结
- 当block的存储在栈上
- block不会对内部使用的对象变量产生强引用
- 当block的内存在堆上
- block在堆区时，在block内部使用对象变量时，会调用block内部的copy函数，copy函数会调用_Block_object_assign函数，_Block_object_assign函数会根据捕获的对象的修饰符类型做出相应的操作，最终决定block是对对象强引用还是若引用
- block销毁时，会调用block内部的dispose函数，根据dispose函数内部的_Block_object_dispose函数会自动释放引用的对象变量
网友评论