背景

block这个概念从我一开始写OC的时候就接触了，也是在概念、用法等方面有一些含糊的地方，今天又一次碰到了之前写的代码，所以特此来总结一下。

类型

block是一个匿名函数，也是一个特殊的Objective-C对象。做为Objective-C对象的block是设置在栈上的，属于_NSConcreteStackBlock类。

内部实现

假设我们有一个main.m的文件
里面的内容如下：

#import <Foundation/Foundation.h>
int main () {
    int a = 10;
    void (^block)(void) = ^ {
    };
    return 0;
}

大家可以用如下命令查看我们定义了一个block在编译后的文件中是什么样子，

clang -rewrite-objc main.m

从编译后的文件中找到main函数，可以发现block的结构定义如下：

void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

那么__main_block_impl_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编译之后是一个结构体，结构体里还有一个结构体成员变量，存储着block的实现:

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

可以看到有一个函数指针void *FuncPtr，它负责存储着block的实现。

属性修饰符

block做为属性时，一般使用copy来修饰，将其复制到堆上，栈区的变量是由编译器负责分配和释放的。变量的作用域结束时，栈上的__block变量和block都会被废弃，而复制到堆上的__block变量和block在变量作用域结束时不受影响，可以正常的进行访问。

修改变量

大家应该都知道使用 __block修饰符修饰block的外部变量后，就可以在block内部修改外部变量, 是因为改变了变量的作用域。那么具体是什么样子的呢。我们再看下具体是怎么实现的结构，我们将上边的代码修改成如下所示:

#import <Foundation/Foundation.h>

@interface MyClass:NSObject
- (void)fun;
@end

@implementation MyClass
- (void) fun {
    __block int a = 10;
    void (^block)(void) = ^ {
        a = 11;
    };
    block();
}

@end

int main () {
    MyClass  *objectName = [[MyClass alloc]init] ;
    [objectName fun];
    return 0;
}

此时大家可以在编译后的文件中看到fun函数被编译成如下形式：

static void __MyClass__fun_block_func_0(struct __MyClass__fun_block_impl_0 *__cself) {
  __Block_byref_a_0 *a = __cself->a; // bound by ref

        (a->__forwarding->a) = 11;
}

我们首先看看传入的这个参数是什么：

struct __MyClass__fun_block_impl_0 {
  struct __block_impl impl;
  struct __MyClass__fun_block_desc_0* Desc;
  MyClass *self;
  __Block_byref_a_0 *a; // by ref
  __MyClass__fun_block_impl_0(void *fp, struct __MyClass__fun_block_desc_0 *desc, MyClass *_self, __Block_byref_a_0 *_a, int flags=0) : self(_self), a(_a->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

可以看到参数里会持有当前实例：

 MyClass *self;

我们的变量a 则变成了 __Block_byref_a_0 *a; 也就是一个引用类型，这个类型的定义是：

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

此时我们就可以理解了，fun在执行的时候会传入一个fun函数的实现的结构体。结构体里有一个成员变量__Block_byref_a_0 a 包含了对变量a的引用。当我们在block里改变变量的值的时候。实际上是通过这个a（指的是__Block_byref_a_0类型的这个a）找到对外部变量a（__block int a ）的引用 然后修改外部变量的值：

(a->__forwarding->a) = 11;

block内的指针

大家都知道在block内部使用外部指针的时候（尤其是self）要使用弱饮用的指针。否则就会导致循环引用。还有一个注意的事情是：在block内部如果调用了延时函数还使用弱指针会取不到该指针，因为已经被销毁了，需要在block内部再将弱指针重新强引用一下。并不是因为weak的指针必须转换成原来的指针。

总计

block的基本实现就是一个结构体，__block修饰符的作用是将变量生成一个带引用的新的类型，然后在block内部通过这个新的类型来操作外部变量，同时block内部使用指针类型的变量的时候弱引用的指针一定要在强引用一次。