iOS之block，一点小心得

　　作为一个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 = ;
        void (^block)() = ^(){
            NSLog(@"%i", i);
        };
        block();
    }
    return ;
}

　　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(, );
    }
    return ;
}
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 = ;
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();
}

　　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(, , , )];
    self.testView.block = ^{
        NSLog(@"没有引用self");
    };
    [self.view addSubview:self.testView];

}

　　在block中，没有引用self，所以当前控制器didDisAppear之后就销毁了。

-- ::33.556 noRetainBlock[:] TestViewController 被释放
-- ::33.557 noRetainBlock[:] 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");
}

　　最后，控制器消失之后被释放

-- ::15.482 noRetainBlock[:] show
-- ::17.784 noRetainBlock[:] TestViewController 被释放

　　不要问我，为什么testView没有被释放，因为根本就没有创建这个对象，哈哈，被show了吧。还有一种写法我试过了，也会造成retain cycle，将testView不设为控制器的属性，这样不会有警告，但是最终还是会造成循环引用，因为析构函数没有被调用。

　　以上两种均可以避开循环引用，不过貌似第一种没啥用。因为不在里面操作self的一些方法貌似这个block没啥意义，说到底也只写了一种。至于还有没有其他的写法，我还没有研究。以后要是发现了会补上的。接下来，我们将看看block到底是什么东西。

　　在看block源码之前，我们先回到下面这段代码，仔细看看会发现，i被__block修饰了。

__block int i = ;
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 = ;
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=) : 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 = { , sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        int i = ;
        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 ;
}

　　源码中__main_block_impl_0和__main_block_desc_0中的信息告诉我们block的本质了，它有一个isa指针，可以将block看成一个对象，但是不能说它就是一个对象。在上述源码中可以看到，block中将变量i拷贝了一份，也就是说，block外面的i和里面的i是两个变量。就好像实参和行参的关系。行参将实参拷贝了一份，放在内存中。oc做了优化，不能直接改变局部变量i的值。但是用__block修饰变量i之后就可以改变了。这又是为啥呢，看下面的源码(只看main中的)：

__block int i = ;
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*),(__Block_byref_i_0 *)&i, , sizeof(__Block_byref_i_0), };
        void(*block)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, ));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    }
    return ;
}

　　我们可以看到__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是一个很有趣的东西，掌握它，弄清楚原理，才能更好的使用它。