浅谈 Block 捕获外部变量和 __block 实现原理

block 是 C 语言的扩充功能，也被称为带有自动变量(局部变量)的匿名函数。block 在网络请求的回调中起着举足轻重的作用。下面就来一步步的探索它使用方法。

完整的 block 语法是如下形式：
block 的声明格式：

返回值类型 (^blockName)(参数列表);
// block的声明
int (^sumblock)(int arg1, int arg2);
void (^blockName)(int arg1, int arg2)

block 的定义格式

返回值类型 (^block变量名)(形参列表) = ^(形参列表) {
};

声明并使用 block
开发者使用 ^ 操作符声明 block 变量，^ 表示是一个 block 的开始。block 的 body 体在 { }之内。例如：

int multiplier = 7;
int (^myblock)(int) = ^(int num) {
  return num * multiplier;
};

block 可以使用“在其定义作用范围内的”变量；如果你声明了一个 block 变量，可以像函数一样使用它。

block的用法

无参数无返回值的 block

void (^blockName)() = ^{
  NSLog(@"无参数,无返回值的block");
};
blockName();

有参数无返回值的 block

void (^blockName)(int a, int b) = ^(int a, int b) {
  NSLog(@"%d + %d = %d",a,b,a+b);
};
blockName(10,10);

有参数有返回值的 block

int (^sumblock)(int a, int b) = ^(int a, int b){
  return a + b;
};
int sum = sumblock(10,10);
NSLog(@"sum = %d",sum);

block 结合 typedef 使用

typedef int (^sumblock)(int, int);

interface ViewController ()
property (nonatomic, copy, nonnull) sumblock sumblock;
@end

@implementation ViewController
- (void)viewDidLoad {
  [super viewDidLoad];
  self.sumblock = ^(int a, int b) {
    return a + b;
  };
  NSLog(@"sum = %d",self.sumblock(10,10));
}

`block` 作为函数参数

block 作为 C 函数参数

// 1.定义一个形参为block的C函数
void useblockForC(int(^ablock)(int, int))
{
  NSLog(@"result = %d", ablock(300,200));
}

// 2.声明并赋值定义一个block变量
int(^addblock)(int, int) = ^(int x, int y){
  return x+y;
};

// 3.以block作为函数参数,把block像对象一样传递
useblockForC(addblock);

// 将第2点和第3点合并一起,以内联定义的block作为函数参数
useblockForC(^(int x, int y) {
  return x+y;
});

block 作为 OC 函数参数

// 1.定义一个形参为block的OC函数
- (void)useblockForOC:(int(^)(int, int))ablock
{
  NSLog(@"result = %d", ablock(300,200));
}

// 2.声明并赋值定义一个block变量
int(^addblock)(int, int) = ^(int x, int y){
  return x+y;
};

// 3.以block作为函数参数,把block像对象一样传递
[self useblockForOC:addblock];

// 将第2点和第3点合并一起,以内联定义的block作为函数参数
[self useblockForOC:^(int x, int y){
  return x+y;
}];

通过下面几个例子，探讨 block 是如何实现的：

例子1：

#include <stdio.h>
int main()
{
  void (^blk)(void) = ^{
    printf("Hello, World!\n");
  };
  return 0;
}

为了研究编译器是如何实现 block 的，我们需要使用 clang。clang 提供一个命令，可以将 Objetive-C 的源码改写成 c 语言的，借此可以研究 block 具体的源码实现方式：

clang -rewrite-objc block.c

转化之后，生成 block.app：

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

从结构体的命名可以看出这是 block 的实现，block 在 clang 编译器编译之后，生成了一个 __block_impl 结构体，isa 指针表明了 block 可以是一个对象，而 FuncPtr 指针显然是 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;
  }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  printf("Hello, World!\n");
}

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

下面我们就具体看一下是如何实现的，__main_block_impl_0 就是该 block 的实现，从中我们可以看出：

__main_block_impl_0 中包含了两个成员变量和一个构造函数，成员变量分别是 __block_impl 结构体和描述信息 __main_block_desc_0，之后在构造函数中初始化 block 的类型信息和函数指针等信息。
__main_block_func_0 函数，即 block 对应的函数体。该函数接受一个 __cself 参数，即对应的 block 自身。
__main_block_desc_0 结构体，其中 Block_size 存储 block 大小。

从上面代码，可以看出执行 block 就是调用一个以 block 自身作为参数的函数，这个函数对应着 block 的执行体。

例子2：

block 如何捕获自动变量

int main()
{
  int i = 1024;
  void (^blk)(void) = ^{
    printf("%d",i);
  };
  blk();
  return 0;
}

通过clang编译之后：

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=0) : 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
  printf("%d",i);
}

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

如果尝试修改局部变量，编译会报错：

图示

在 __main_block_impl_0 中，可以看到自动变量 i，被 block 从外面捕获进来，成为 __main_block_impl_0 这个结构体的成员变量了。

接着看构造函数，

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int flags=0) : i(_i)

这个构造函数中，自动变量被捕获为成员变量追加到了构造函数中。
block 捕获外部变量仅仅只捕获 block 闭包里面会用到的值，其他用不到的值，它并不会去捕获。

我们注意到 __main_block_func_0 这个函数的实现，

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int i = __cself->i; // bound by copy
  printf("%d",i);
}

我们可以发现，系统自动给我们加上的注释，bound by copy，自动变量 i 虽然被捕获进来了，但是是用 __cself->i 来访问的。block 仅仅捕获了 i 的值，并没有捕获 i 的内存地址。所以在 __main_block_func_0 这个函数中即使我们重写这个自动变量 i 的值，依旧没法去改变 block 外面自动变量i 的值。

编译器基于这一点，在编译的层面就防止开发者可能犯的错误，因为自动变量没法在 block 中改变外部变量的值，所以编译过程中就报编译错误，错误原因告诉我们变量不可赋值，也提醒我们要使用 __block 类型标识符。错误就是最开始的那张截图。

自动变量是以值传递方式传递到 block 的构造函数里面去的。block 只捕获 block 中会用到的变量。由于只捕获了自动变量的值，并非内存地址，所以 block 内部不能改变自动变量的值。

例子3：

静态局部变量是如何在 __block 执行体中被修改的。

int main(int argc, char * argv[]) {
    static int i = 10;
    void (^blk)(void) = ^{
        i = 30;
        printf("%d", i);
    };
    blk();
    return 0;
}

通过clang编译之后：

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=0) : 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

        (*i) = 30;
        printf("%d", (*i));
    }
}
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, char * argv[]) {
    static int i = 10;
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &i));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

在 __main_block_impl_0 中，可以看到静态变量 i，被 block 从外面捕获进来，成为 __main_block_impl_0 这个结构体的成员变量了。

接着看构造函数，

__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_i, int flags=0) : i(_i)

这个构造函数中，静态变量被捕获为成员变量追加到了构造函数中。
block 捕获外部变量仅仅只捕获 block 闭包里面会用到的值，其他用不到的值，它并不会去捕获。__main_block_impl_0 结构体中成员 i 变成指针类型(int *)。静态变量传递给 block 是内存地址值，所以能在 block 里面直接改变值。

当然，全局变量、静态全局变量都可以在 block 执行体内被修改。因为是全局的，作用域很广，所以 block 捕获了它们进去之后，block 结束之后，它们的值依旧可以得以保存下来。更准确地讲，block 可以修改它被调用(这里是 __main_block_func_0 )时所处作用域内的变量。比如一个 block 作为成员变量时，它也可以访问同一个对象里的其它成员变量。

例子4：

__block 类型变量是如何支持修改。
int 类型变量加上__block指示符，使得变量 i 可以在 block 函数体中被修改：

int main()
{
    __block int i = 1024;
    void (^blk)(void) = ^{
        i = 1023;
        printf("%d",i);
    };
    blk();
    return 0;
}

通过 clang 编译之后：

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int 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;
  }
};

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) = 1023;
  printf("%d",(i->__forwarding->i));
}

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

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 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()
{
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 1024};
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

从中可以看出，多出了一个 __Block_byref_i_0 的结构体：

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

__isa 指针也可以知道 __Block_byref_i_0 也可以是对象。
__forwarding 指针指向 __Block_byref_i_0
成员变量 i，用来存储使用到的局部变量 i。

__main_block_impl_0 对应的结构体：

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

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) = 1023;
  printf("%d",(i->__forwarding->i));
}

__main_block_impl_0 的成员变量 i 变成了 __Block_byref_i_0* 指针类型。
__Block_byref_i_0 指针类型变量 i，通过其成员变量 __forwarding 指针来操作另一个成员变量。

注意：
__Block_byref_i_0 类型变量i仍然处于栈上，当 block 被回调执行时，变量 i 所在的栈已经被展开。
查看 __main_block_desc_0 结构体，发现：

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

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 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};

此时，__main_block_desc_0 多了两个成员函数：copy 和 dispose，分别指向 __main_block_copy_0和 __main_block_dispose_0。

当 block 从栈上被 copy 到堆上时，会调用 __main_block_copy_0 将 __block 类型的成员变量 i 从栈上复制到堆上；而当 block 被释放时，相应地会调用 __main_block_dispose_0 来释放 __block 类型的成员变量 i。如果栈上和堆上同时对该变量进行操作，__forwarding 的作用就体现出来了，当一个 __block 变量从栈上被复制到堆上时，栈上的那个 __Block_byref_i_0 结构体中的 __forwarding 指针也会指向堆上的结构。

最后编辑于：2022.02.10 19:24:34

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,214评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,307评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,543评论 0赞 341
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,221评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,224评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,007评论 1赞 284
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,313评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,956评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,441评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,925评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,018评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,685评论 4赞 322
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,234评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,240评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,464评论 1赞 261
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,467评论 2赞 352
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,762评论 2赞 345