Block是啥？

Block又称作匿名函数，是苹果引入的，在C、C++、Objective-C下均可使用。其他的一些语言把Block又称作闭包或lambada表达式。

Block的写法

block的典型语法为：

^ 返回值类型 (参数列表) {实现体}

具体到实例：

^ void (void) {
    printf("I am a block");
}

当参数不存在时其可以省略：

^ void {
    printf("I am a block");
}

反回值也可以省略，当实现体中有多个retrun时其每个ruturn反回的数据类型必须一致，上述Block省略之后如下：

^ {
    printf("I am a block");
}

定义一个n的平方的block如下：

^ (int n) {
    return n * n;
}

上述Block省略了返回值。

可以看到block的确是没有名字，那么叫他匿名函数也就不足为奇了；上面代码展示的都是block的实现，那么到底如何调用这样的匿名函数呢？

我们可以将block赋值给对应的变量，然后利用该变量来使用此block。

block类型的变量声明方式如下：返回值类型 (^变量名) (参数列表)；不出意外你能想到一个与之十分类似的声明；函数指针的声明void (*funcPtr) (void)；两者的区别仅仅在与符号^和*。

结合变量使用Block

int (^mySquare)(int) = ^ (int n) {
    return n * n;
};

int result = mySquare(10);
printf("%d\n",result);

上述函数会输出100。

Block实现的窥探与变量捕获

我们可以利用clang的-rewrite-objc xxx.m指令来将Objective-C重写成C++从而来窥探其Blcok的实现。

在使用Block的时候，其内部难免会用到外部的变量，那么Block如何处理这些外部变量也是一个十分重要的问题。

-rewrite-objc

为了使生成的C++代码足够简单，我们创建一个简单的文件block_learn.m，其中写入如下代码(不需要导入头文件)：

int main (int argc, char * argv[]) {
    void (^myBlock) (void) = ^ {
        int i = 1 + 1;
    };
    myBlock();
}

在终端输入：clang -rewrite-objc block_learn.m。可以看到当前文件夹下多了一个block_learn.cpp文件。

在C++文件中我们可以看到：

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

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;
    }
}

static void __main_block_func_0(struct __main_block_impl_0 * __cself) {
    int i = 1 + 1;
}

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, int * argv[]) {
    void (*myBlock)(void) = (void (*)()&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
}

Block实际上被编译器转换成了__main_block_impl_0结构体（C++类）；该结构体中有两个成员变量：

• struct __block_impl类型的 impl
• 该Block的描述指针（struct __main_block_desc_0 * Desc）

可以看到__block_impl中的各个成员的含义：

• void * isa; 表示该结构体所属的类（Objective-C）,因此可以说block是对象。
• int Flags; 标志位。
• int Reserved; 保留字段。
• void * FuncPtr; 函数指针，指向Block实现的内容。

struct __main_block_desc_0各个成员含义：

• size_t reserved; 保留字段
• size_t Block_size; Block的大小。

代码中有一个静态的struct __main_block_desc_0类型的结构体，并初始化为：{0, sizeof(struct __main_block_impl_0)}

再来看真正做事情的函数：__main_block_func_0,注意，该函数的返回值与Block的返回值一致，但是在参数列表中，第一位会被设置为该block C++实现类型的指针struct __main_block_impl_0 * __cself；

我们继续查看__main_block_impl_0的构造函数；该构造函数拥有三个参数：

• void * fp; 即funcPtr, 业务的函数指针。
• struct __mian_block_desc_0 * desc; block的描述结构体指针。
• int flags; 标志位， 默认为0。

其中的都是一些简单的赋值操作；值得一提的是：impl.isa = &_NSConcreteStackBlock;，该句话表明这个block是栈上的Block；常用的还有：_NSConcreteSGlobalBlock（全局）、_NSConcreteMallocBlock（堆）。

我们看mian函数是怎么转换Block代码的；myBlock实际上是由struct __main_block_impl_0构造初始化的对象的首地址，只不过将这个首地址强制转换成了函数指针（void (*myBlock)(void)）。

首先要知道myBlock实际是一个struct __main_block_impl_0结构体（对象）的指针，因此调用时，先将myBlock转换成__block_impl类型的指针，然后再取其FuncPtr所指向的执行业务的函数指针；最后调用这个函数指针，并按照参数列表传入参数（第一个参数是struct __main_block_impl_0 *类型的__cself,故将myBlock转换为恰当的类型并传入其中）。

至此一个不包含其他外界变量的block就分析完成了。

变量捕获

要知道实际应用中，必然会遇到包含其他外部变量的block，也就是说一定会遇到变量的捕获。对于基本的变量可以分为以下几种类型：

• 局部变量
• 静态局部变量
• 具有内部连接的静态变量(static)
• 具有外部连接的静态变量(extern)

接着，我们修改原先的Objective-C代码为如下：

static int i = 10;
extern int j = 20;
int main (int argc, char * argv[]) {
    static int k = 30;
    int l = 100;
    void (^myBlock) (void) = ^ {
        i + i;
        j + j;
        k + k;
        l + l;
   };
   myBlock();
}

我们在其中加入了这四种类型的变量，分别为i、j、k、l。

通过-rewrite-objc后查看到__main_block_impl_0的变化如下：

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

__main_block_func_0的变化：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    int *k = __cself->k;
    int l = __cself->l;
    
    i + i;
    j + j;
    *(k) + *(k);
    l + l;
}

main函数的变化：

int main (int argc, char * argv[]) {
    static int k = 30;
    int l = 100;
    void (*myBlock) (void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &k, l));
   ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
}

可以看到，对于写在函数外部的static、extern类型的静态变量，block没有捕获它们，而是直接使用，这是因为这些变量本身的生命周期就是与应用程序的生命周期一致的，因此不需要花费额外的空间来保留这些变量。

对于局部变量，在作用域结束时就已经释放了，如果这时使用将会造成崩溃；而对block来说，它的生命周期常常与局部变量是不一致的，因此block在自己的结构体内部保留了该局部变量的副本。这也解释了为什么在定义block之后修改其捕获的局部变量无效。

对于静态局部变量，block在其内部保留了一个指向它的指针。为什么这里是保留一个指针呢？由于静态局部变量的生命周期也是与程序保持一致的，因此没有必要在block内保留其副本，而想要跨域访问变量指针是在合适不过的。

对象的捕获

将Objective-C源码修改为：

int main (int argc, char * argv[]) {
    NSObject *obj = [[NSObject alloc] init];
    void (^myBlock) (void) = ^ {
        obj;
    };
    myBlock();
}

执行-rewrite-objc后，发现在__main_block_impl_0的实现中，仅仅添加了一个成员变量：NSObject *obj;。

但是却增加了__main_block_copy_0，__main_block_dispose_0函数，这两个函数用于对象的内存管理。

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->obj, (void*)src->obj, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->obj, 3/*BLOCK_FIELD_IS_OBJECT*/);
}

可以看到__main_block_copy_0中调用了_Block_object_assign，该方法相当于retain；而__main_block_dispose_0调用了_Block_object_dispose,这个方法相当于release。我们没能在生成的代码中找到调用它的位置，他们是被自动调用的。当block由栈复制到堆上的时候会调用
copy函数，而当堆上的block被废弃时则会调用dispose函数。Block在以下情况会复制到堆上：

• 调用Block的Copy方法时
• 将Block作为函数的返回值时
• 将Block赋值给具有__strong修饰符id类型的类或Block类型成员变量时
• 方法名中有usingBlock的Cocoa框架方法或者GCD的API传递Block时

下表展示了对各类block调用copy方法时的效果：

同时__main_block_desc_0有所变化，其变化，就是加入了用于管理内存的两个函数指针。

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_D

对于main函数，仅仅是将Objective-C对象的方法，转换成了消息发送，其余的与普通变量的捕获一致。

__block变量

如下代码在编译的时候就会报错：

int i = 6;
^ {
    i += 10; //Variable is not assignable (missing __block type specifier)
};

经过刚刚的分析可以知道，在block内部保留着i的副本，但是对外并不能够访问到；因此报错也就不难理解。

为了研究__block变量，我们将i用__block修饰，代码修如下:

int main (int argc, char * argv[]) {
    __block int i = 0;
    void (^myBlock) (void) = ^ {
       i = 100;
    };
    myBlock();
}

通过-rewrite-objc指令之后可以看到block实现内部多了__Block_byref_i_0 *i;完整结构如下：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

这个名为：__Block_byref_i_0的结构就是__block类型的变量，其完整定义如下：

struct __Block_byref_i_0 {
    void *__isa;
    __Block_byref_i_0 *__forwarding;
    int __flags;
    int __sizes;
    int i;
}

第一个参数为isa指针，那么由此知道，被__block修饰的变量可以看做是一个特殊的Objective-C对象。第二个参数为__forwarding其指向与自己类型一致的结构体。第三个参数为标志位；第四个参数为自身的大小。最后一个参数与被__block修饰的原变量一致。

实际的函数被转换为：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

       (i->__forwarding->i) = 100;
}

与此同时，还能够发现，代码中增加了__main_block_copy_0函数和__main_block_dispose_0函数；该函数用于复制和释放__block修饰的变量。

而 __main_block_desc结构体也有所改变：

struct __main_block_desc {
    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};

__main_block_desc增加了copy和dispose两个函数指针，并在初始化的时候将函数__main_block_copy_0和__main_block_dispose_0赋值给了相应的指针。

main函数中的变化：

int main (int argc, char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 0}; // 1
    void (*myBlock) (void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344)); // 2
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock); // 3
}

第一行初始化__block修饰的变量，将其* __isa设置为(void *)0;__forwarding设置为自己的首地址；__flags设置为0；__size设置为sizeof(__Block_byref_i_0);i设置为初始化的值。

对对象使用__block

对对象使用block后是什么样子的呢？

如下代码转换后：

#include <Foundation/Foundation.h>

int main (int argc, char * argv[]) {
    __block NSObject *obj = [[NSObject alloc] init];
    void (^myBlock) (void) = ^ {
        obj;
    };
    myBlock();
}

其struct __Block_byref_obj_0结构体有所改变

struct __Block_byref_obj_0 {
  void *__isa;
__Block_byref_obj_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSObject *obj;
};

其增加了用于对象内存管理的两个函数指针__Block_byref_id_object_copy和__Block_byref_id_object_copy。并且在main函数中初始化的时候传入的flags设置为了0x2000000

int main (int argc, char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_obj_0 obj = {(void*)0,(__Block_byref_obj_0 *)&obj, 33554432, sizeof(__Block_byref_obj_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131, ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"))};
    void (*myBlock) (void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_obj_0 *)&obj, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
}

不难发现，使用到原__block变量i时都被转换成了i->forwarding->i;，那么为什么会用这这种方式呢？

block和__block变量在初始化的时候都是在栈上的。但由于栈上的空间生命周期非程序员可控的，经常出现跨域使用的情形，因此block和__block变量都是可复制到堆上的。当调用block的copy方法时block内的__block变量也会一起被复制到堆上。在复制__blcok变量到堆上时，会将栈上__block变量的__forwarding指向到堆中的变量，这保证了栈上的变量也能够正确访问复制到堆上的变量。

循环引用

使用weak解决

使用block时可能会造成循环引用，如果类A的对象a拥有一个block b,而block中也引用了a，那么就会造成循环引用。可以在block外部使用__weak类型的变量以供block内部引用来解决循环引用的问题。（ps:凡是构成了环装引用的都会造成循环引用）

使用__block解决

@interface ViewController ()

@property (nonatomic, copy) void(^blk)(void);

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    __block ViewController *tempSelf = self;
    self.blk = ^{
        NSLog(@"%@",tempSelf);
        tempSelf = nil;
    };
 }
 

如上述代码所示，只要在适当的地方调用过block那么其将tempSelf置为nil后，就不会造成循环引用（或者在适当的地方将tempSelf置为nil；可以不在block内）。使用此种方式解决循环引用，有一点要切记，必须要在适当的时机将tempSelf置为nil。

ps: 在非ARC环境下，__block也可以与__unsafe_unretained修饰符一样来避免block的循环引用。

// 该代码 非ARC下不会造成循环引用； 但是ARC下则会造成循环引用
- (id)init {
    if (self = [super init]) {
        __block id tmp = self;
        _blk = ^ {
            NSLog(@"%@",tmp);
        };
    }
    return self;
}

--

参考资料：

[1] Kazuki Sakamoto. Objective-C高级编程：iOS与OS X多线程和内存管理. 人民邮电出版社