Blocks是iOS4之后引入的新特性，Blocks顾名思义为块，引申为代码块，使用Blocks可以很轻松的实现匿名函数以及函数的传递。

目录

• Blocks语法
• Block变量
• 截获自动变量
• Blocks实现
  • 自动变量
  • __block变量
• Block生命周期
• __block生命周期

Blocks语法

Blocks语法还是挺简单的，在C语言中，一个完整的函数需要包含返回值+函数名+参数列表+函数体，每一项都不可以省略，而在Blocks中，大部分都可以省略，除了Blocks的标志符^与方法体，一个完整的Blocks是这样的:

//完整Blocks
^int (int a){return a;}
//省略返回值的Blocks,返回值默认与return类型一致
^(int a){return a;}
//省略返回值与参数列表的Blocks
^{//爱干嘛干嘛}

Block变量

Blocks与函数相比，不仅书写上简便，运用上也更加灵活。Blocks可以作为变量使用，如下所示:

//名为blk的block变量
int (^blk)(int);
//给它赋值
blk=^int (int a){return a;}
//使用它
blk(1);

如果需要在函数返回值中返回Block，则可以写成如下形式

//func函数被"包裹"起来了
int (^func())(int){
    return ^(int a){return a;};
}

这样写阅读起来会比较麻烦，通用的做法是使用typedef定义一个类型。

typedef int (^blk_t)(int);

blk_t func(){
    return ^(int a){return a;};
}

截获自动变量

Blocks有两个十分重要的特性:

• 截获自动变量
• 截获变量不可修改

例如:

int a=1;
void (^blk)(void)=^{printf("a=%d\n",a);};
a=2;
blk();

打出的LOG是a=1，详细原理下文再详细解读，简单来说就是当block被创建的时候会自动截获它的函数体中所包含的变量。

截获的变量不可以修改，例如这样:

void (^blk)(void)=^{
            a=2;
            printf("a=%d\n",a);};

编译器会报错：

Variable is not assignable (missing __block type specifier)

自动变量不可修改，那对象是否能够修改呢，例如这样：

NSMutableArray arr=[[NSMutableArray alloc]init];
void (^blk)(void)=^{
            
            arr=[[NSMutableArray alloc]init];
            };

这样也是不行的，那我们折中一下，换成修改对象结构呢？

NSMutableArray arr=[[NSMutableArray alloc]init];
void (^blk)(void)=^{
            id obj=[[NSObject alloc]init];
            [arr addObject:obj];
            };

这样是被系统允许的，究其原因是因为第二种修改方式虽然修改了arr的结构，但是它指向的地址却没有被修改，所以即使我们调用addObject修改了arr的结构，在系统看来也只是"使用"arr而已。

如果非要在Block中修改变量，我们可以使用__block修饰符修饰变量。就像这样

__block int a=1;
void (^blk)(void)=^{
a=3;
printf("a=%d\n",a);};
a=2;
blk();

打出的LOG为a=3。

Block实现

自动变量

Block语法虽然看起来有些复杂，但是被编译的时候还是作为C语言源代码来编译的。
让我们用clang编译器编译一下，虽然与LLVM编译器有点差异，但是差异不是很大，看看在clang下的代码，对理解Blocks有很大好处。我们编译这段最简单的代码，在xcode新建一个OC文件

int a=1;
void (^blk)(void)=^{
printf("a=%d\n",a);};
blk();

我们找到目录下的main.m文件，在命令行输入

cd main.m文件所在目录
clang -rewrite-objc main.m

我们会编译出一个main.cpp文件。打开文件，会出现一大堆代码，但是这都不是我们需要关注的，我们要关注的只是一小段代码。拖到底部，这段才是我们需要关注的代码。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy

            printf("a=%d\n",a);}

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 a=1;
        void (*blk)(void)=((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
        ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
        return 0;

    }

}

很明显

void (^blk)(void)=^{printf("a=%d\n",a);};

被编译成了

void (*blk)(void)=((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

我们把类型转换的语法删除，其实剩下的就是

*blk=__main_block_impl_0(__main_block_func_0,&__main_block_desc_0_DATA,a);

我们接着看，__main_block_impl_0实际上是一个结构体，调用的是它的构造方法。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

C++中，构造函数后面紧跟着冒号加初始化列表，各初始化变量之间以逗号(,)隔开。因此，当我们初始化block的时候，变量值已经被存储到结构体的变量中了。在block后改变自动变量的值就会“失效”。

那轮到我们调用block的时候又是怎样来调用的？

((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);

是不是看得一头雾水，一步一步先把前面的格式去掉，式子就还剩

((__block_impl *)blk)->FuncPtr)((__block_impl *)blk)

到这里我们大致可以明白，blk先被强制类型转换成__block_impl,然后再调用其中的FuncPtr变量。在我们去看__block_impl定义之前，先关注一下blk的类型，blk是一个void指针类型，但是实际上它指向的是__main_block_impl_0这个结构体。这个结构体的空间结构如下:

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

既然调用了FuncPtr变量，那我们就从头开始寻找它到底什么时候被赋值，结果发现在blk初始化的时候传入的__main_block_func_0最终被赋到了FuncPtr上，__main_block_func_0就是我们的匿名函数:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy

            printf("a=%d\n",a);}

到这里就可以解释前面两个重要的特性了:

• 截获自动变量

截获的变量在初始化的时候就被存储起来，使用的时候再拿出来

• 截获变量不可修改

这主要是因为截获的变量为自动变量，再次使用的时候超出了自动变量的作用域，如果换成其他全局或者静态变量则可以被修改。这里可能还有人要较真，如果是静态局部变量呢？不是也和自动变量一样超出作用域了吗？这里偷懒就不贴代码了，当变量为静态局部变量时，block中保存的是静态局部变量的指针而不是静态局部变量的值，最后修改的时候会通过保存下来的指针找到静态局部变量再进行修改，因此可以在block中修改静态局部变量。似乎自动变量也可以通过保存指针的方式进行存储，其实是行不通的。究其原因是因为自动变量的生命周期会随作用域的结束而结束，即使保存了指针也无法访问到自动变量，而静态变量的生命周期是整个程序的生命周期。

这是简单的block实现图，画得丑大概就这样了

__block变量

上文说到自动变量在block中是不可修改的，如果非要修改可以加上__block修饰符，那我们编译一下，看看block又是怎么处理__block修饰符的。

源代码:

int __block a=1;
int __block b=2;
void (^blk)(void)=^{
   a=3;
   b=4;
   printf("a=%d\n,b=a=%d\n",a,b);};
blk();

编译后:

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};
struct __Block_byref_b_1 {
  void *__isa;
__Block_byref_b_1 *__forwarding;
 int __flags;
 int __size;
 int b;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_a_0 *a; // by ref
  __Block_byref_b_1 *b; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, __Block_byref_b_1 *_b, int flags=0) : a(_a->__forwarding), b(_b->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a; // bound by ref
  __Block_byref_b_1 *b = __cself->b; // bound by ref

            (a->__forwarding->a)=3;
            (b->__forwarding->b)=4;
            printf("a=%d\n,b=a=%d\n",(a->__forwarding->a),(b->__forwarding->b));}
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*/);_Block_object_assign((void*)&dst->b, (void*)src->b, 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*/);_Block_object_dispose((void*)src->b, 8/*BLOCK_FIELD_IS_BYREF*/);}

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; 

        __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 1};
        __Block_byref_b_1 b = {(void*)0,(__Block_byref_b_1 *)&b, 0, sizeof(__Block_byref_b_1), 2};
        void (*blk)(void)=((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, (__Block_byref_b_1 *)&b, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
        return 0;

    }

}

编译后的代码略长，跟上面分析一样的流程就不说了。看点不一样的。很显然，我们加过__block修饰符的变量已经成为一个结构体了。

这是它的构造函数以及初始化过程:

__Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 1};

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

这个结构体不仅存储了我们赋予的值(1)，还存储了自身结构体的指针(forwarding)，这主要是为了保证数据的一致性，等到__block变量生命周期时再解释:

这是block的构造函数:

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, __Block_byref_b_1 *_b, int flags=0) : a(_a->__forwarding), b(_b->__forwarding) 

我们传入的a以指针的形式被存储了下来。最后是修改__block部分

  __Block_byref_a_0 *a = __cself->a; // bound by ref
  __Block_byref_b_1 *b = __cself->b; // bound by ref

            (a->__forwarding->a)=3;
            (b->__forwarding->b)=4;

Block先拿到自身保存的a(结构体)的指针，再从指针中拿到指向a(结构体)的指针，最后从该指针从拿到保存的a(变量)的值进行修改。这么说可能有点绕，但是过程就是这样，__block将变量包裹起来，然后把指针传递给Block保存，需要修改的时候再从Block->__block->变量拿出来。

Block生命周期

Block在oc中被当做对象来处理，其成员变量中的isa可以佐证这一点。
isa有三种参数

• NSConcreteStackBlock
• NSConcreteGlobalBlock
• NSConcreteMallocBlock

这三个参数分别对应着Block的存储域(栈，堆，data区)。
我们之前的代码中，Block作为一个自动变量出现，因此参数为NSConcreteStackBlock，如果把Block做成一个全局变量或者静态变量，那么参数就会变成NSConcreteGlobalBlock。不过在ARC中，NSConcreteStackBlock大部分在编译时就被转换成了NSConcreteMallocBlock或者NSConcreteGlobalBlock。这种转换是有好处的，可以使Block超出作用域存在。

一般来说，大部分的Block都生成在栈上，栈上Block的生命周期与所属变量的作用域同步。

void (^blk)(void)=^{printf("a=%d\n",a);};

当blk的作用域结束时，Block也被废弃了。看上去合情合理，接着看下面的例子：

typedef int (^blk_t)(int);
{
    NSArray *arr=[self getArr];
    blk_t blk=(blk_t)[arr objectAtIndex:0];
    blk();
}
-(NSArray*)getArr{
    int a=10;
    //Block被做成了自动变量并作为参数传入方法
    return [[NSArray alloc]initWithObjects:^{NSLog(@"1000000000%d",a);},^{NSLog(@"20000000");}, nil];
}

这段代码在ARC是能够运行的，但是在MRC中却有可能CRASH掉，错误为EXC_BAD_ACCESS，原因在于我们试图访问一个已经被释放的对象。
当我们运行到blk()之前是这样的：

当调用blk()之后就变成了这样：

如果在ARC中又会怎样呢？如图所示:

return [[NSArray alloc]initWithObjects:^{NSLog(@"1000000000%d",a);},^{NSLog(@"20000000%d",a);}, nil];

正确的写法应该是这样，手动的把Block复制到堆里，虽然写法有点奇怪

return [[NSArray alloc]initWithObjects:[^{NSLog(@"1000000000%d",a);} copy],[^{NSLog(@"20000000%d",a);} copy], nil];

总结一下，Block的生命周期和它被做成的对象有很大关系，做成NSStackBlock时常常在自动变量作用域结束时被释放，如果想要延长Block的生命周期，可以将Block copy到堆上(ARC中系统会自动帮忙做，当Block被作为方法参数时例外)，堆上的Block不随栈上Block的释放而释放，堆上的Block遵循对象的引用计数方式管理生命周期。

__block变量的生命周期

__block变量的生命周期和Block差不多,也是一言不合就释放的主，上文说到Block会被复制到堆中，Block中的__block自然也是"嫁鸡随鸡，嫁狗随狗"了，那么问题来了，既然是复制，那么同一时间，__block有可能会存在两个(栈与堆),这可不行，因为我们要保证数据的一致性，万一栈上的__block修改了变量，而堆上的没有修改，那就会导致数据不一致。为了防止这种情况的发生，__block采用了__forwarding。__block被复制的时候，__forwarding指向堆上的block，而堆上的__forwarding仍然指向自身。如图所示：