Block是我们在日常OC编码中经常使用的特性，它可以非常便捷高效的编写和组织代码，可以让异步调用的代码更加的精炼易读。但是在日常开发过程中我们大部分情况都是写着教科书一般的代码来确保编码的正确,下面我们通过block的源码分析来看看block的实现原理。文章有点长，请耐心点哦，相信你一定有所收获的。
正常我们在使用block时会写出如下的代码：
- (void)function{
__weak typeof(self) weakself = self; //创建一个指向当前对象的弱引用
[teseObject callFunc:^{
__strong typeof(self) strongself = weakself; //block内部定义一个指向当前对象的强引用
[strongself callFunc_1:....];
[strongself callFunc_2:....];
....
}];
}
现在我们来带着问题分析一下上面的这个代码：
1. 可不可以直接使用self？
不可以。因为这样block会强持有self对象，造成循环引用，从而导致内存泄露。
2. 可不可以直接使用weakself?
看情况。由于weakself不会持有对象，因此不会造成循环引用的问题，但是使用weakself却会造成block执行不一致问题，试想一下上面的代码，当调用“callFunc_1”的时候weakself是有效的，但是当调用“callFunc_2”的时候weakself可能已经是nil了，这样就造成了block内执行不一致从而导致意想不到的结果
3. 循环引用是不是都是坏人？
答案是否定的。当block开始执行的时候，strongself会去取self对象的值，如果此时self已经为nil，那么整个block执行期间strongself都是nil，如果self有效那么strongself就是利用了循环引用的特性保证了在block执行的时候self对象不会被析构，保证block执行的一致性。其实我们在编写业务代码的时候（很多第三方开源类库）中会利用到循环引用的这一特性来保证block中引用的对象在block执行的时候依然有效，但是切忌使用这样黑魔法的时候要在block执行结束后打破循环引用。由于strongself是block内部定义的变量，在block执行结束会由系统回收从而打破循环引用
总结：使用strongself可以消除循环引用带来的内存泄漏，也可以保证block执行过程中的一致性。所以正常的业务代码我们都会使用上面的标准方式编写，只有特殊的情况才会利用block的特性写一些黑魔法的代码。
接下来我们就来通过解读block的源码来看看block到底干了些什么，首先我们先来看看下面这些长得像面试题的东西，如果执行的结果大家觉得疑惑就继续读下去，如果没有任何疑惑也可以继续读下去指正一下：
NSInteger count = 10;
NSInteger(^sum)(void)=^{
return count;
};
count = 20;
NSLog(@"\\n %ld",sum()); //结果：10
__block NSInteger block_count = 10;
NSInteger(^block_sum)(void)=^{
return block_count;
};
block_count = 20;
NSLog(@"\\n %ld",block_sum()); //结果：20
NSMutableString *mutable_string = [NSMutableString stringWithString:@"aaa"];
void(^mutable_append)(void)=^{
[mutable_string appendString:@"ccc"];
};
[mutable_string appendString:@"bbb"];
mutable_append();
NSLog(@"\\n %@",mutable_string); //结果：aaabbbccc
NSString *string = @"aaa";
NSString*(^append)(void)=^{
return [string stringByAppendingString:@"ccc"];
};
string = @"bbb";
NSLog(@"\\n %@",append()); //结果：aaaccc
__block NSString *block_string = @"aaa";
NSString*(^block_append)(void)=^{
return [block_string stringByAppendingString:@"ccc"];
};
block_string = @"bbb";
NSLog(@"\\n %@",block_append()); //结果: bbbccc
依然让我们带着问题来分析上面的代码：
1. 不加__block就不能修改变量？
答案是否定的。首先我们要理解这里所说的修改的概念：修改指针 or 修改真实值。在block内部对一个没有加__block的变量进行重新赋值，编译器会报错。其实编译器做法很简单——不准修改这个变量所指向的那个区域的内容，对于值类型那个区域存放的是真实值，对于引用类型那个区域存放的是指向另一个内存的指针值。而对于引用类型真实值的修改编译器是不会做任何限制的。
总结：当在block内修改一个值类型变量的时候，需要加上 “__block”，在block内修改一个引用类型变量的时候分情况讨论，如果需要将这个变量完全指向另一个内存对象，加上“__block”, 如果只是单纯的修改指针所指向的对象则不需要使用“__block”。
上面都是从理论的角度来解释Objective-C中block的使用规则，下面来通过C的代码来看看block的实现源码，下面的每一段代码是和Objective-C代码相对应的：
--------Objective-C 代码--------
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
NSInteger count = 10;
NSInteger(^block)(void)=^{ return count; };
NSLog(@"\\n %ld",block());
return 0;
}
--------C 代码--------
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
NSInteger count;
//构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSInteger _count, int flags=0) : count(_count) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
//block 的C++函数实现
static NSInteger __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSInteger count = __cself->count; // bound by copy
return count;
}
//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)};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
NSInteger count = 10;
NSInteger(*block)(void)=((NSInteger (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, count));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_16_pkj1k8l97qbcp79805czcy580000gn_T_main_6bdb2c_mi_0,((NSInteger (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block));
}
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
代码分析：
为了便于理解我将Objective-C代码中得block变量声明和赋值写成了一行，这样方便对比C代码中的main函数并有下面的几点发现：
- “^”变成了“*”,可以看出block其实是C中的函数指针。
- 最重要的代码是：结构体__main_block_impl_0 和 函数__main_block_func_0
- __main_block_impl_0 是block的真面目：它是一个结构体，count变量就是被block捕获的外部变量在结构体中的新定义；__block_impl可以看成面向对象里的基类其中定义了block结构体的通用属性，其中最重要的时FuncPtr函数指针；__main_block_impl_0(...)这个就是block结构体的构造函数了，函数的参数中有一个“NSInteger count”，这个就是构建block实例时传入的count值，从这个地方就可以看出在block变量在初始化赋值的时候就已经将值类型直接放进了结构体，所以后续的改动都不会影响block所捕获的这个count值。
- __main_block_func_0 是Objective-C中定义的block体，是block真正要执行的函数，当执行block时会通过上面block结构体中得FuncPtr指针找到这个函数来执行。它直接返回的就是结构体中的count，所以也证明了后面的修改是不会影响block捕获的变量值。
- 再来看main函数里的代码就清晰很多了，最重要的就是第二句——“NSInteger(block)(void)=((NSInteger ()())&__main_block_impl_0((void )__main_block_func_0, &__main_block_desc_0_DATA, count));”* 先通过结构体的构造函数初始化结构体，传入预先定义好的block真正要执行的函数指针，block的描述和值变量count。然后通过“&”取结构体实例的地址并通过((NSInteger ()())进行指针的强制类型转换成函数指针付给“block”指针变量。最后一句代码“((NSInteger ()(__block_impl ))((__block_impl )block)->FuncPtr)((__block_impl )block)”是用来执行block的，代码很清晰，将函数指针转成__block_impl** 结构体指针并执行其中FuncPtr指向的函数。
下面我们再看一下加上“__block”之后的代码
--------Objective-C 代码--------
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
__block NSInteger count = 10;
NSInteger(^block)(void)=^{ return count; };
NSLog(@"\\n %ld",block());
return 0;
}
--------C 代码--------
//定义一个保存变量的结构体
struct __Block_byref_count_0 {
void *__isa;
__Block_byref_count_0 *__forwarding;
int __flags;
int __size;
NSInteger count;
};
//block的结构体
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_count_0 *count; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_count_0 *_count, int flags=0) : count(_count->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
//block的C++函数
static NSInteger __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_count_0 *count = __cself->count; // bound by ref
return (count->__forwarding->count);
}
//block的copy函数
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->count, (void*)src->count, 8/*BLOCK_FIELD_IS_BYREF*/);}
//block的析构函数
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->count, 8/*BLOCK_FIELD_IS_BYREF*/);}
//block的描述结构体
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;
__attribute__((__blocks__(byref))) __Block_byref_count_0 count = {(void*)0,(__Block_byref_count_0 *)&count, 0, sizeof(__Block_byref_count_0), 10};
NSInteger(*block)(void)=((NSInteger (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_count_0 *)&count, 570425344));
NSLog((NSString *)&__NSConstantStringImpl__var_folders_16_pkj1k8l97qbcp79805czcy580000gn_T_main_10c601_mi_0,((NSInteger (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block));
}
return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };
代码分析：
- 查看main函数，对比之前的代码可以很清晰的看到了不一样的地方，原先定义“NSInteger count=10”的地方变成了一个结构体(** __Block_byref_count_0**)指针的定义和初始化代码并将count变量传给了结构体的构造函数，所以可以看出“__block”的作用就是定义一个新的结构体来包裹原来的变量。
- 查看block的结构体定义“** __main_block_impl_0**”，count变量类型也变成了一个结构体指针。
- 查看block执行函数“** __main_block_func_0**”，里面的count变量已经一个结构体类型了，所以这下我们可以结合之前的理论知识--block内是可以改变指针所指向的那个对象值，在block外面修改count的时候事实上也是修改的结构体指针所指结构体对象的内部值。
总结：没有使用“__block”时，内部是直接使用了该变量，对于值类型变量是直接定义新变量并赋值相同，对于引用类型变量是定义一个新变量并copy它。当使用“__block”时，会增加一个结构体将变量包起来，对于值类型变量就相当于变成指针，对于引用类型相当于变成了指针的指针。
下面的代码是对于全局static变量在block中使用的代码解析：
为了简单清晰，我只保留了block结构体和block执行函数
--------Objective-C 代码--------
static NSString *string = @"hello";
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
NSString*(^block)(void)=^{
NSString *appendString = @"world";
return [string stringByAppendingString: appendString];
};
NSLog(@"\\n %ld",block());
return 0;
}
--------C 代码--------
static NSString *string = (NSString *)&__NSConstantStringImpl__var_folders_16_pkj1k8l97qbcp79805czcy580000gn_T_main_2919dd_mi_0;
//最终的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;
}
};
//真正的block函数
static NSString * __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSString *appendString = (NSString *)&__NSConstantStringImpl__var_folders_16_pkj1k8l97qbcp79805czcy580000gn_T_main_2919dd_mi_1;
return ((NSString *(*)(id, SEL, NSString *))(void *)objc_msgSend)((id)string, sel_registerName("stringByAppendingString:"), (NSString *)appendString);
}
代码分析：
- 查看bloc k的结构体可以发现并没有捕获copy变量而是在结构体的执行方法中直接使用了全局静态变量，所以执行时才去取值，一直都是获取变量的最新值.
下面的代码是在类中使用类变量或属性时的代码解析：
这里定义了一个“TestObject”的测试类，在类的“myFunction”中定义了一个block变量并初始化
struct __TestObject__myFunction_block_impl_0 {
struct __block_impl impl;
struct __TestObject__myFunction_block_desc_0* Desc;
TestObject *self;
__TestObject__myFunction_block_impl_0(void *fp, struct __TestObject__myFunction_block_desc_0 *desc, TestObject *_self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __TestObject__myFunction_block_func_0(struct __TestObject__myFunction_block_impl_0 *__cself) {
TestObject *self = __cself->self; // bound by copy
(*(NSString **)((char *)self + OBJC_IVAR_$_TestObject$_test)) = (NSString *)&__NSConstantStringImpl__var_folders_16_pkj1k8l97qbcp79805czcy580000gn_T_TestObject_44e9ab_mi_0;
}
static void __TestObject__myFunction_block_copy_0(struct __TestObject__myFunction_block_impl_0*dst, struct __TestObject__myFunction_block_impl_0*src) {_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __TestObject__myFunction_block_dispose_0(struct __TestObject__myFunction_block_impl_0*src) {_Block_object_dispose((void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static struct __TestObject__myFunction_block_desc_0 {
size_t reserved;
size_t Block_size;
void (*copy)(struct __TestObject__myFunction_block_impl_0*, struct __TestObject__myFunction_block_impl_0*);
void (*dispose)(struct __TestObject__myFunction_block_impl_0*);
} __TestObject__myFunction_block_desc_0_DATA = { 0, sizeof(struct __TestObject__myFunction_block_impl_0), __TestObject__myFunction_block_copy_0, __TestObject__myFunction_block_dispose_0};
static void _I_TestObject_myFunction(TestObject * self, SEL _cmd) {
((void (*)(id, SEL, Block))(void *)objc_msgSend)((id)self, sel_registerName("setBlock:"), ((void (*)())&__TestObject__myFunction_block_impl_0((void *)__TestObject__myFunction_block_func_0, &__TestObject__myFunction_block_desc_0_DATA, self, 570425344)));
}
代码分析：
- 看第一个代码块就可以很清楚的看到了block结构体定义了一个TestObject变量并在初始化方法中将该变量赋值从而实现了对原来self对象的copy并持有了它，这样就形成了循环引用了。
总结：通过上面对局部值变量、局部引用类型变量、全局变量和类变量的理论解释和源代码分析，相信大家对block已经能够彻底扫盲，关于weakself和strongself的源码分析留给大家思考吧。文章主要是梳理了一下我们日常使用中的一些概念和原理，具体使用还是看具体场景，希望对大家有帮助。
