看了很多别人写的Block的相关文章，但是别人写的终究是别人的，看过之后没多久也就忘了。真正的动手敲敲，仔细考究一下，然后用自己的思路总结出来，才会转化为自己的东西，才会牢记于心，这也是我写这篇文章的原因。

1. Block是什么

答：是匿名函数，是闭包，是对象。

但是怎么理解呢？

匿名函数：是说在定义Block时，其名称可以省略不写；
闭包：封闭的包，呵呵，看Block写法就知道了。
还有人理解为闭包就是能够读取其它函数内部变量的函数
这中说法怎么理解呢？
就是闭包允许一个函数访问声明该函数运行上下文中的变量，甚至可以访问不同运行上文中的变量。

**用脚本语言来解释：**
function funA(callback){
    alert(callback());
}
function funB(){
    var str = "Hello World"; // 函数funB的局部变量，函数funA的非局部变量
    funA（
        function（）{
            return str;
        }
    ）；
}
通过上面的代码我们可以看出，按常规思维来说，变量str是函数funB的局部变量，作用域只在函数funB中，函数funA是无法访问到str的。但是上述代码示例中函数funA中的callback可以访问到str，这是为什么呢，因为闭包性。

来自：http://www.cocoachina.com/ios/20150109/10891.html

**用OC语言来解释：**
#import <Cocoa/Cocoa.h> 
  
void logBlock( int ( ^ theBlock )( void ) ) 
{ 
    NSLog( @"Closure var X: %i", theBlock() ); 
} 
  
int main( void ) 
{ 
    NSAutoreleasePool * pool; 
    int ( ^ myBlock )( void ); 
    int x; 
  
    pool = [ [ NSAutoreleasePool alloc ] init ]; 
    x    = 42; 
  
    myBlock = ^( void ) 
    { 
        return x; 
    }; 
  
    logBlock( myBlock ); 
  
    [ pool release ]; 
  
    return EXIT_SUCCESS; 
} 
 
上面的代码在main函数中声明了一个整型，并赋值42，另外还声明了一个block，该block会将42返回。
 
然后将block传递给logBlock函数，该函数会显示出返回的值42。

即使是在函数logBlock中执行block，而block又声明在main函数中，但是block仍然可以访问到x变量，并将这个值返回。

个人觉得这个例子很low，感觉只是个值传递的过程，并不能很好的解释闭包。

来自：http://www.cocoachina.com/ios/20130715/6599.html

对象：:我们都知道，Objective-C中的对象，其实是一个struct（结构体），所有的对象的数据结构里面都有一个isa指针，
那我们可以使用clang工具来看看Block的数据结构是怎样的：

新建一个block.m文件，里面的代码：

int main(int argc, char * argv[]) {
    void (^block)(void) = ^{
//        NSLog(@"hello");
    };
}

在终端使用命令clang -rewrite-objc block.m之后，会产生一个block.cpp文件，其中__main_block_impl_0：就是block的实现源码；

屏幕快照 2016-05-23 22.08.15.png

可以看到Block其实也是一个struct，内部也有一个isa指针，指向这个Block的类型：NSConcreteStackBlock。

所以block也是对象

2. Block的写法

• 声明一个block：

返回值（^ 名称）（参数列表）＝ ^（参数列表）{
  //balabala
}；

• block作为函数的参数:

-(void)testAction:（返回值（^）（参数列表））名称

• 使用typedef来声明一个全局的block变量

type 返回值 （^ 名称）（参数列表）

3. Block的类型

我们都知道block有三种类型

__NSConcreteGlobalBlock__;
__NSConcreteStackBlock__; 
__NSConcreteMallocBlock__;

怎么理解这三种类型呢？

顾名思义：

__NSConcreteGlobalBlock__://存储在全局数据区域的block，不会访问任何外部变量
__NSConcreteStackBlock__; //存储在栈上的block，出栈时会被销毁
__NSConcreteMallocBlock__;//存储在堆上的block，当引用计数为0时会被销毁

站在代码表现形式的角度来说：

• 没有引用外部变量的block就是__NSConcreteGlobalBlock__；
• 引用了外部变量的block就是__NSConcreteStackBlock__；
• 对__NSConcreteStackBlock__进行copy或Block_copy()操作后，就会变为__NSConcreteMallocBlock__。

具体看代码：

    NSString * (^block1)() = ^
    {
        NSString *str = @"block1";
        
        return str;
    };
    
    NSString *str = @"block1";
    NSString * (^block2)() = ^
    {
        return str;
    };
    
    NSString * (^block3)()  = Block_copy(block2);
    NSString * (^block4)()  = [block2 copy];
    
    NSLog(@"block1-> %@", block1);
    NSLog(@"block2-> %@", block2);
    NSLog(@"block3-> %@", block3);
    NSLog(@"block4-> %@", block4);

输出日志：
**2016-06-04 10:39:14.910 BlockTest[1113:33102] block1-> <__NSGlobalBlock__: 0x5b090>**
**2016-06-04 10:39:14.910 BlockTest[1113:33102] block2-> <__NSStackBlock__: 0xbffab070>**
**2016-06-04 10:39:14.911 BlockTest[1113:33102] block3-> <__NSMallocBlock__: 0x7885c6f0>**
**2016-06-04 10:39:14.911 BlockTest[1113:33102] block4-> <__NSMallocBlock__: 0x7885c680>**

当然，也可以用命令clang -rewrite-objc block.m生成中间层代码，看每一个block中的isa的值也可以得到block的类型。

注：在ARC环境下，是不存在__NSConcreteStackBlock__的，因为ARC下，编译器会隐式的对一些变量进行copy操作，那原先的__NSConcreteStackBlock__就会变为__NSConcreteMallocBlock__。

所以ARC环境下只会存在两种block：
__NSConcreteGlobalBlock__
__NSConcreteMallocBlock__

4. Block引用/修改外部变量

• 引用外部变量
  对于 block 外的变量引用，block 默认是将其复制到其数据结构中来实现访问的。

怎么来理解这句话呢？

还是用代码来说话：

    int a = 1;
    int (^block1)() = ^()
    {
        int c = a;
        return c;
    };
    
    a = 2;
    NSLog(@"%d",block1());
    输出：
    2016-06-17 14:19:45.550 Test[33356:4066610] 1

说明：
由于block1在声明的时候，变量a的值已经被复制到block1中使用了，所以下一行虽然变量a的值改变了，但是block1中使用的那个值是不会受到影响的。

那么引用过程到底发生了什么呢？

使用命令clang -rewrite-objc block.m生成中间层代码：

屏幕快照 2016-06-18 12.05.08.png

从下往上看，最下面就是main函数，

//block1的声明
int (*block1)() = ((int (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

main_block_impl_0：就是block1的内部实现结构；
__main_block_func_0：就是block1对应的函数执行方法；
其中，对变量a的使用是通过int a = __cself->a; // bound by copy来实现的；
main_block_desc_0：block1的描述信息，main_block_impl_0 中由于增加了一个变量a，所以结构体的大小变大了，该结构体大小被写在了main_block_desc_0中，Block_size就是block1的大小。

所以block引用外部变量，其实是在自己的结构中生成了一个相同的内部变量，然后在block执行的时候，将block外部变量的值赋给内部变量。

也就是说block捕获了这个变量（Capture local variable）

这样就能理解，在 block 外部再去修改变量 a 的内容，是不会影响内部的实际变量 a 的值了。

如果此时我在block1中去修改a的值会怎样呢？

屏幕快照 2016-06-18 12.19.16.png

报错了，需要添加__block修饰这个变量才可以，分析一下原因：

看看源码，可以知道变量a在main函数中声明，所以当block1被调用后，函数__main_block_func_0已经出了a的作用区域，显然是无法修改a的值的。

int a = __cself->a; // bound by copy只是将a的值从main中传到__main_block_func_0中，变量a的作用域还是没有变。

这就就相当于你在一个函数中去访问另外一个函数中的局部变量，当然时引用不到的。
当然，也可以通过变量的指针来修改变量的值，但是当block被执行的时候，引用的这个变量可能已经不在栈中了，那么此时这个变量指针就成为了野指针，此时再访问就会crash。

等等，既然是由于作用域的问题，那么如果是全局变量的话，其作用域整个程序，不需要__block会出现上面的问题吗？

int b = 1;
int main(int argc, char * argv[]) {
    __block int a = 1;
    void (^block2)(void) = ^()
    {
        a = 2;
        b = 2;
    };
    
    block2();
}

屏幕快照 2016-06-18 15.26.26.png

可以看到函数__main_block_func_0是直接对变量b进行赋值修改的

• 修改外部变量
  上面讲到对变量用__block来修饰之后，就可以在block中修改这个变量，那么这中间发生了什么呢？

对下面代码rewrite之后，可以看到：

    int main(int argc, char * argv[]) {
    __block int a = 1;
    void (^block2)(void) = ^()
    {
        a = 2;
    };
    
    block2();
}

屏幕快照 2016-06-18 12.10.41.png

可以看到多了一些结构：
__Block_byref_val_0：其实就是__block修饰的变量
其内部有一个__forwarding，是指向自己的，在重新给变量a赋值的时候，其实是给__Block_byref_val_0中的a赋值。

简单的说：

1. __block修饰后的成员变量，其实是将这个成员变量包装成了一个结构体__Block_byref_val_0；
2. 在block捕获变量为__block修饰的外部变量时，才会出现这两个函数：

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}

3.调用__main_block_copy_0会将__block类型的成员变量从栈上复制到堆上；而当block被释放时，相应地会调用__main_block_dispose_0来释放__block类型的成员变量。

4.此时，栈上和堆上都存在__block变量，即使栈上的变量作用域结束，堆上的仍然可以使用。

5.那么什么时候block会复制到堆上呢？

• 调用block的copy方法。

• block作为函数返回值返回时。

• block调用外面的_strong的id的类时，或用_block时。

• 方法中，用usingblock或者GCD中的API时。

• 循环引用&内存泄漏

了解了上述原因，也就知道了为什么会产生循环引用的现象了：

对于引用外部变量的这种情况来说，block会在内部结构中生成一个相同的内部变量，那么这在MRC下就会使该变量的retaincount加1，在ARC的情况下，就会持有该变量，形成一个强引用的状态，那么如果这个变量是self，那么此时block和self之间就会出现你中有我，我中有你的情况，也就是循环引用现象了，如果这个变量是一个对象的话，就可能会因为无法释放而出现内存泄露。

那如何解决呢？
本质上主要是破环这种你中有我，我中有你的关系，那么：
在ARC环境下，可以用__weak来修改self，产生一个weakself，这样，当block外部的self释放后，内部引用的weakself就回自动释放；

在MRC环境下，使用__block来修饰变量。
本身无法避免循环引用的问题，但是我们可以通过在 block 内部手动把 blockObj 赋值为 nil 的方式来避免循环引用的问题。另外一点就是 __block 修饰的变量在 block 内外都是唯一的，要注意这个特性可能带来的隐患。

文中代码见： demo

• 问题：
  为什么系统的block，AFN网络请求的block内使用self不会造成循环引用?

1. UIView的动画block不会造成循环引用的原因就是，这是个类方法，当前控制器不可能强引用一个类，所以循环无法形成。

2. AFN无循环是因为绝大部分情况下，你的网络类对象是不会被当前控制器引用的，这时就不会形成引用环。
AFN中的block并没有引用控制器对象。

AFN中的block处理方法

参考：
http://blog.csdn.net/jasonblog/article/details/7756763
http://www.cocoachina.com/ios/20130802/6725.html
http://www.cocoachina.com/ios/20150106/10850.html
http://www.cocoachina.com/ios/20160307/15441.html
http://www.jianshu.com/p/1383d56a7ca3
http://www.jianshu.com/p/51d04b7639f1