作为一个iOS开发程序员，没用过block是不可能的。这次我探讨的是block原理，但是有些更深层次的东西，我也不是很清楚，以后随着更加了解block将会慢慢完善。
第一个问题，什么是block？
我们都会用block，但是block是什么呢，这是首先要弄清楚的概念。虽然，是什么并不影响我们用它，但是搞清楚原理我们才能更好的去使用它，我觉得作为一个程序员，需要时刻保持对事物原理追究的心态？
block的是本质是对象。但是你也可以说它是代码块、闭包、内联函数、函数指针...还有很多叫法，也可能这里的叫法都是错误的，或是不准确的，但是我个人觉得从功能上讲，可以这么理解。不过为了对oc的尊敬，还是叫它block吧，block就是block。在其他语言中也有类似block的语法，像javascript的闭包，函数里面的函数，java中的代码块，c中的函数指针等。就好像，事先放一段代码在这里，然后需要的时候回过头来调用。我们知道，代码执行是按顺序调用的，也就是我们常说的面向过程。但是block可以反向调用。只不过block可以写在函数里面，也可以说它是函数中的函数，它是比较特殊的函数。我们看下面的一个例子。
int main(int argc, const char * argv[]) {
@autoreleasepool {
int i = 0;
void (^block)() = ^(){
NSLog(@"%i", i);
};
block();
}
return 0;
}
block先放在i=0;的后面，但是它没有立即执行，在使用block()；后它才执行，这就是block。至于block本质，到后面会讲到。
第二个问题，为什么要用block？
虽然知道了什么是block，但是我们为什么要用呢？什么情况下用呢？这个问题其实也很重要，要掌握他的应用场景，我们才能用好它。
最常用的情况，网络请求。当调用网络的的API请求服务器的数据的时候，我们不知道什么时候才会完成，这个时候程序也不可能停下来等待请求完成再继续运行，这样肯定是不行的。在请求成功的时候，去执行一些操作，这个时候我们需要做到一件事，就是执行事先已经准备好的一段代码。这种情况不正好与block吻合了吗，block不就是来干这件事的吗？有人会说，用代理也可以做到啊，没错，代理也可以实现这种场景需要的操作。但是block它的好处在于简洁，代理以后再谈。
再举一个例子，你写了一个页面，页面上有按钮可以点击，但是点击事件是用户点了之后才触法的，而你的响应事件想放在控制器中处理(遵循一下MVC设计模式)。这个时候，也可以用block。
总的来说，当你的程序中需要用到回调的时候，用block会让你思路清晰，代码简洁。
第三个问题，如何用block？
1.block的定义：void(^a)()=^(){};
=前面：
void:返回值类型；
()():语法结构，第一个括号里面是block名字,第二个括号里面是参数列表，和c或java中参数列表写法一样；例如：int i,char c...
^:脱字符，block标识
a:block名称，就像函数名，对象实例化名称，说白了就是一个名字；
=号后面：
^是block标识；
()参数列表，当没有参数时，可以省略，但是“=”前面的()参数列表不能省略；
{}要执行的代码放在这里面，最后加“;”
最后调用，a();跟方法的调用何其相似。但是它和方法有一个非常明显的区别，方法可以在当前类中(或是在main函数中)都可以调用，但是block不同，它出了它所在的作用域就不能被调用了。就像变量一样，说到这里，你是不是想到了奖block设为全局。没错，下面我们使用一下全局block。
2.全局block
void(^globeBlock)(int, int);
void max(int, int);
int main(int argc, const char * argv[]) {
@autoreleasepool {
globeBlock = ^(int i, int j){
printf("%d\n", i>j?i:j);
};
max(1, 2);
}
return 0;
}
void max(int i, int j){
globeBlock(i,j);
}
上面的代码中，我们可以看到，声明了一个全局的block，在main函数中实现，在max方法中调用。这样就可以让block在全局中都能调用，但是一定要实现block，否则会报错。全局block原理和变量一样，这里不多说了。有全局block，那么有没有静态block呢(别打我，我也是推测)，试了一下，好像没有，也可能我写法不对。
3.将block用作为对象的属性。
创建一个类Block，.h文件中：
typedef void (^block)();
@interface Block : NSObject
@property (nonatomic, assign) block myBlock;
- (void)start;
.m文件中
- (void)start{
if (self.myBlock) {
self.myBlock();
}
}
在main函数中：
__block int i = 0;
Block *block = [Block new];
block.myBlock = ^{
i++;
};
[block start];
这种写法是比较常用的，但是也会造成一些问题，例如：retain cycle，这个放在后面说。
4.将block作为变量传递。
还是用上面的类举例。.h文件中：
- (void)show:(void (^)(NSInteger index))paramBlock;
.m文件中
- (void)show:(void (^)(NSInteger index))paramBlock{
paramBlock(1);
}
main函数中调用：
[block show:^(NSInteger index) {
NSLog(@"%li", index);
}];
这样就将block当作变量传递了，一些网络请求库里面会经常用这种方式。
上面讲到的有关block的概念都是一些比较基础的东西，下面会讲block更深层的理论。
1.retain cycle，循环引用一直是一个老生常谈的问题，我相信99.9的oc程序员都遇到过，并都能很好的解决，所以我这里也不赘述，简单说一下。
retain cycle在block中是怎么产生的。自从iOS引进了ARC之后，内存管理变得方便，但同时有些情况让人头疼。当对象A持有对象B的时候，A释放，B会随着A的释放而释放。那么问题来了，如果B也持有对象A，那么A会随着B的释放而释放。很好，现在A、B都在等对方释放，互相伤害啊，结果大家都不释放，这样便造成了循环引用。用weak关键字修饰，或是用其他的方法，都可以解决，这里不多说，没多大意思了。
2.不会形成retain cycle的block。像UIKit中UIView的block动画它不会形成retain cycle，还有网络库AF中的回调也不会形成retain cycle。没有形成retain cycle说明没有互相强引用，UIView调用的是类方法，当前控制器不可能强引用一个类，所以并没有造成retain cycle；至于AF里面怎么做到的，说实话我也不是很清楚，哈哈，还要研究一下。既然如此，那我们来写写不会造成循环引用的block。
2.1block里面没有引用当前控制器
视图控制器是TestViewController,有一个属性testView,类TestView代码如下：
.h
@interface TestView : UIView
{
NSString *str;
}
@property (nonatomic, copy) void(^block)();
@end
.m
#import "TestView.h"
@implementation TestView
- (void)dealloc{
NSLog(@"TestView 被释放");
}
- (instancetype)initWithFrame:(CGRect)frame{
if (self = [super initWithFrame:frame]) {
self.backgroundColor = [UIColor blackColor];
UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(click)];
[self addGestureRecognizer:tap];
}
return self;
}
- (void)click{
if (self.block) {
self.block();
}
}
@end
TestViewController代码如下：
- (void)dealloc{
NSLog(@"TestViewController 被释放");
}
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
self.view.backgroundColor = [UIColor whiteColor];
self.testView = [[TestView alloc] initWithFrame:CGRectMake(100, 200, 50, 50)];
self.testView.block = ^{
NSLog(@"没有引用self");
};
[self.view addSubview:self.testView];
}
在block中，没有引用self，所以当前控制器didDisAppear之后就销毁了。
2017-07-07 11:16:33.556 noRetainBlock[1319:39876] TestViewController 被释放
2017-07-07 11:16:33.557 noRetainBlock[1319:39876] TestView 被释放
会造成循环引用的情况：
然后TestViewController和TestView都没有被释放,成功造成retain cycle。用weak修饰一下self就可以了，这里不说了。
2.2类方法调用，block作为变量，TestView代码如下：
.h
@interface TestView : UIView
@property (nonatomic, copy) void(^block)();
+ (void)show:(void(^)())myBlock;
@end
.m
#import "TestView.h"
@implementation TestView
- (void)dealloc{
NSLog(@"TestView 被释放");
}
- (instancetype)initWithFrame:(CGRect)frame{
if (self = [super initWithFrame:frame]) {
self.backgroundColor = [UIColor blackColor];
UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(click)];
[self addGestureRecognizer:tap];
}
return self;
}
- (void)click{
if (self.block) {
self.block();
}
}
+ (void)show:(void (^)())myBlock{
myBlock();
}
@end
控制器中调用：
- (void)dealloc{
NSLog(@"TestViewController 被释放");
}
- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.
self.view.backgroundColor = [UIColor whiteColor];
[TestView show:^{
[self show];
}];
}
- (void)show{
NSLog(@"show");
}
最后，控制器消失之后被释放
2017-07-07 11:40:15.482 noRetainBlock[1608:52010] show
2017-07-07 11:40:17.784 noRetainBlock[1608:52010] TestViewController 被释放
不要问我，为什么testView没有被释放，因为根本就没有创建这个对象，哈哈，被show了吧。还有一种写法我试过了，也会造成retain cycle，将testView不设为控制器的属性，这样不会有警告，但是最终还是会造成循环引用，因为析构函数没有被调用。
以上两种均可以避开循环引用，不过貌似第一种没啥用。因为不在里面操作self的一些方法貌似这个block没啥意义，说到底也只写了一种。至于还有没有其他的写法，我还没有研究。以后要是发现了会补上的。接下来，我们将看看block到底是什么东西。
在看block源码之前，我们先回到下面这段代码，仔细看看会发现，i被__block修饰了。
__block int i = 0;
Block *block = [Block new];
block.myBlock = ^{
i++;
};
[block start];
那么不用__block修饰会是什么样子呢？答案是：如果在block中修改局部变量i的值，那么编译器会报错，根本不能通过编译，不过你要打印或是给其他变量赋值还是可以的。既然这样，我们来看看上述写法和下面写法的两种源码，在终端cd到main函数所在文件夹，使用命令 clang -rewrite-objc main.m会得到main.cpp的文件。可以查看源码。
第一种，不用__block修饰，打印变量i：
int i = 0;
void(^block)() = ^{
NSLog(@"%i", i);
};
block();
cpp文件中，末尾，因为大概有95000行代码，只取最后部分代码
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int i;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int flags=0) : i(_i) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int i = __cself->i; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_s1_pqp17thd18bdxjswsty3xkmh0000gn_T_main_e26a0c_mi_0, i);
}
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 i = 0;
void(*block)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
源码中__main_block_impl_0和__main_block_desc_0中的信息告诉我们block的本质了，它有一个isa指针，可以将block看成一个对象，但是不能说它就是一个对象。在上述源码中可以看到，block中将变量i拷贝了一份，也就是说，block外面的i和里面的i是两个变量。就好像实参和行参的关系。行参将实参拷贝了一份，放在内存中。oc做了优化，不能直接改变局部变量i的值。但是用__block修饰变量i之后就可以改变了。这又是为啥呢，看下面的源码(只看main中的)：
__block int i = 0;
void(^block)() = ^{
i++;
NSLog(@"%i", i);
};
block();
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};
void(*block)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
我们可以看到__attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0};被__block修饰过的变量i变成这样了，然后在block中的i是(__Block_byref_i_0 *)&i，一个地址。原来，用__block修饰过的i传入block里面时，是地址，所以可以改变i的值。
其实还有一个变量的值是可以在block中修改的，全局变量，静态变量。但是要注意，在改变变量的值的时候要注意循环引用的问题。
总结：block是一个很有趣的东西，掌握它，弄清楚原理，才能更好的使用它。