探索Block内部构造

1. Block的底层结构

以下是一个没有参数和返回值的最简单的Block：

#include <stdio.h>
int main () {
    void(^blk)() = ^{
        printf("Block");
    };
    blk();
    return 0;
}

为了探索Block的底层结构，需要将main.m文件转化为C++的源码,打开终端命令行。cd到包含main.m文件的文件夹，然后输入:clang -rewrite-objc main.m(以上内容放在main.m内)，这个时候在该文件夹的目录下会生成main.cpp文件。

(如果执行:clang -rewrite-objc main.m报错,首先cd到该文件的目录,然后
在终端将clang -rewrite-objc main.m的命令替换成为:

$ clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk main.m
然后, 你会发现, 你的文件夹中多了一个.cpp的文件, 证明解决了这个问题。
如果你觉得这个命令很繁琐不易记, 你可以采用 alias来起一个别名来代替这个命令。

1.打开终端, 键入命令 vim ~/.bash_profile
2.在vim界面输入i进入编辑编辑状态并且键入:
alias rewriteoc=’clang -x objective-c -rewrite-objc -isysroot /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk’
3.键入完毕后, esc退出编辑状态, 再键入:wq退出vim并保存
4.键入命令source ~/.bash_profile)

好了接下来继续探索block
这个文件非常长，我们直接拉到文件的最下面会看到这些函数：
1.__main_block_impl_0
2.__main_block_func_0
3.__main_block_desc_0
4.main

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("Block");
    }

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 (*)())&__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;
}

这几个函数名不是一直这样的,在不同的文件中会有不同的函数前缀,如在ViewController.m的viewDidLoad方法中显示是以下这样的,但是函数内容是一样的

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

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_v8_yfvtg6s17zq2xn62sgjsf6b00000gn_T_ViewController_d37495_mi_0, a);
    }

static struct __ViewController__viewDidLoad_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __ViewController__viewDidLoad_block_desc_0_DATA = { 0, sizeof(struct __ViewController__viewDidLoad_block_impl_0)};

static void _I_ViewController_viewDidLoad(ViewController * self, SEL _cmd) {
    ((void (*)(__rw_objc_super *, SEL))(void *)objc_msgSendSuper)((__rw_objc_super){(id)self, (id)class_getSuperclass(objc_getClass("ViewController"))}, sel_registerName("viewDidLoad"));


    int a = 1100;
    void (*block)(void) = ((void (*)())&__ViewController__viewDidLoad_block_impl_0((void *)__ViewController__viewDidLoad_block_func_0, &__ViewController__viewDidLoad_block_desc_0_DATA, a));
    a = 20;
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

}

文件靠上部分还有这样一个结构体:__block_impl

#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

首先分析main函数:

int main () {
    void(*blk)() = ((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;
}

第一行代码定义一个block变量，第二行代码是调用block。这两行代码看起来非常复杂。但是我们可以去简化一下，怎么简化呢？
变量前面的()一般是做强制类型转换的，比如在调用block这一行，block前面有一个()是(__block_impl *)，这就是进行了一个强制类型转换，将其转换为一个_block_impl类型的结构体指针，那像这样的强制类型转换非常妨碍我们理解代码，我们可以暂时将这些强制类型转换去掉，这样可以帮助我们理解代码。

化简后的代码如下：

void (* blk)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
blk->FuncPtr(blk);

以上内容看着应该就比较清楚了。
接下来逐行分析，首先第一行：

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

这句代码的意思就是调用_main_block_impl_0这个函数，给这个函数传进两个参数_main_block_func_0和&_main_block_desc_0_DATA,然后得到这个函数的返回值，取函数返回值的地址，赋值给blk这个指针。

接下来看函数:__main_block_impl_0

这是一个C++的结构体。而且在这个结构体内还包含一个函数，这个函数的函数名和结构体名称一致，这在C语言中是没有的，这是C++特有的。

在C++的结构体包含的函数称为结构体的构造函数，它就相当于是OC中的init方法，用来初始化结构体。OC中的init方法返回的是对象本身，C++的结构体中的构造方法返回的也是结构体对象。

那么我们就知道了，__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);返回的就是_main_block_impl_0这个结构体对象，然后取结构体对象的地址赋值给blk指针。换句话说，blk指向的就是初始化后的_main_block_impl_0结构体对象。
我们再看一下初始化_main_block_impl_0结构体传进去的参数：

第一个参数是_main_block_func_0，定义如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Block");
    }

这个函数其实就是把我们Block中要执行的代码封装到这个函数内部了。我们可以看到这个函数内部就一行代码，就是一个printf函数;这句代码。
把这个函数指针传给_main_block_impl_0的构造函数的第一个参数，然后用这个函数指针去初始化_main_block_impl_0这个结构体的第一个成员变量impl的成员变量FuncPtr。也就是说FuncPtr这个指针指向_main_block_func_0这个函数。

第二个参数是&_main_block_desc_0_DATA。

我们看一下这个结构：

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

在结构体的构造函数中，0赋值给了reserved，sizeof(struct __main_block_impl_0)是赋值给了Block_size，可以看出这个结构体存放的是_main_block_impl_0这个结构体的信息。在_main_block_impl_0的构造函数中我们可以看到，_main_block_desc_0这个结构体的地址被赋值给了_main_block_impl_0的第二个成员变量Desc这个结构体指针。也就是说Desc这个结构体指针指向_main_block_desc_0_DATA这个结构体。
那么我们总结一下：

void (* blk)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA);
blockblock->FuncPtr(blk);

1.创建一个函数_main_block_func_0,这个函数的作用就是将我们block中要执行的代码封装到函数内部，方便调用。
2.创建一个结构体_main_block_desc_0,这个结构体中主要包括 _main_block_impl_ 这个结构体占用的存储空间大小等信息。
3.将1中创建的_main_block_func_0这个函数的地址，和2中创建的_main_block_desc_0这个结构体的地址传给_main_block_impl_0的构造函数。
4.利用_main_block_func_0初始化_main_block_impl_0结构体的第一个成员变量impl的成员变量FuncPtr。这样_main_bck_impl_0这个结构体也就得到了block中那个代码块的地址。
5.利用_mian_block_desc_0_DATA去初始化_mian_block_impl_0的第二个成员变量Desc。

下面我们再看第二步调用block：

blk->FuncPtr(blk);

我们知道，block实质上就是指向_main_block_impl_0这个结构体的指针，而FuncPtr是_main_block_impl_0的第一个成员变量impl的成员变量，正常来讲，block想要调用自己的成员变量的成员变量的成员变量，应该像下面这样调用：

blk->impl->FuncPtr

然而事实却不是这样，这是为什么呢？

原因就在于之前我们把所有的强制类型转换给删掉了，之前block前面的()是(__block_impl *)，为什么可以这样强制转换呢？因为block指向的是_main_block_impl_0这个结构体的首地址，而_main_block_impl_0 的第一个成员变量是struct __block_impl impl;，所以impl和_main_block_impl_0的首地址是一样的，因此指向_main_block_impl_0的首地址的指针也就可以被强制转换为指向impl的首地址的指针。

之前说过，FuncPtr这个指针在构造函数中是被初始化为指向_mian_block_func_0这个函数的地址。因此通过blk->FuncPtr调用也就获取了_main_block_func_0这个函数的地址，然后对_main_block_func_0进行调用，也就是执行block中的代码了。这中间block又被当做参数传进了_main_block_func_0这个函数。
现在还没有用到static void __main_block_func_0(struct __main_block_impl_0 *__cself)函数里边的参数,接下来就要用到了

2.变量捕获-auto变量

auto变量是声明在函数内部的变量，比如int a = 0;这句代码声明在函数内部，那a就是auto变量，等价于auto int a = 0;auto变量时分配在栈区，当超出作用域时，其占用的内存会被系统自动销毁并生成。下面看一段代码：

int main () {
 int a = 10;
 void (^block)(void) = ^{
     printf("%d", a);
 };
 a = 20;
 block();
}

这是一个很简单的Block捕获自动变量的例子，我们看一下打印结果：

2019-02-19 09:18:14.088934+0800 Test[761:36119] 10

自动变量a的值明明已经变为了20，为什么输出结果还是10呢？我们把这段代码转化为C++的源码看看。

int main () {
    int a = 10;
    void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
    a = 20;
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}

对比一下上面分析的没有捕获自动变量的源代码，我们发现这里_main_block_impl_0中传入的参数多了一个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;
  }
};

在_main_block_impl_0这个结构体中我们发现多了一个int类型的成员变量a，在结构体的构造函数中多了一个参数int _a，并且用这个int _a去初始化成员变量a。
所以在void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a);中传入了自动变量a用来初始化_main_block_impl_0的成员变量a。那这个时候_main_block_impl_0的成员变量a就被赋值为10了。
由于上面这一步是值传递，所以当执行a = 20时，_main_block_impl_0结构体的成员变量a的值是不会随之改变的，仍然是10。
然后我们再来看一下_main_block_func_0的结构有何变化：

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

        printf("%d", a);
    }

可以看到__main_block_func_0函数中传进来的block使用上了,他就是_cself,里边包含block_impl_0的成员变量,所以这里可以打印a

3.变量捕获-static变量

上面讲的捕获的是自动变量，在函数内部声明的变量默认为自动变量，即默认用auto修饰。那么如果在函数内部声明的变量用static修饰，又会带来哪些不同呢？static变量和auto变量的不同之处在于变量的内存的回收时机。auto变量在其作用域结束时就会被系统自动回收，而static变量在变量的作用域结束时并不会被系统自动回收。
先看一段代码：

int main () {
    static int a = 10;
    void (^block)(void) = ^{
        printf("%d", a);
    };
    a = 20;
    block();
}

我们看一下打印结果：

2019-02-19 09:18:14.088934+0800 Test[761:36119] 20

结果是20，这个和2中的打印结果不一样，为什么局部变量从auto变成了static结果会不一样呢？我们还是从源码来分析：

int main () {
    static int a = 10;
    void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));
    a = 20;
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}

和2不一样的是，这里传入_main_block_impl_0的是&a，也即是a这个变量的地址值。那么这个&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;
  }
};

这里我们可以看到结构体多了一个指针类型的成员变量int *a,然后在构造函数中，将传递过来的&a，赋值给这个指针变量。也就是说，在_main_block_impl_0这个结构体中多了一个成员变量，这个成员变量是指针，指向a这个变量。所以当a变量的值发生变化时，能够得到最新的值。

4.变量捕获-全局变量

2和3分析了两种类型的局部变量，auto局部变量和static局部变量。这一部分则分析全局变量。全局变量会不会像局部变量一样被block所捕获呢？我们还是看一下实例：

#include <stdio.h>
static int a = 10;
int main () {
    void (^block)(void) = ^{
        printf("%d", a);
    };
    a = 20;
    block();
}

打印结果：

2019-02-19 09:18:14.088934+0800 Test[761:36119] 20

我们还是查看一下源码：

static int a = 10;

int main () {
    void (*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    a = 20;
    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}

这里我们可以看到，a这个全局变量没有作为参数传入_main_block_impl_0中去。然后我们再查看一下_main_block_impl_0的结构：

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

可以看到，_main_block_impl_0中并没有增加成员变量。然后我们再看_main_block_func_0的结构：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("%d", a);
    }

可以看到，这个地方在调用的时候是直接调用的全局变量a。
所以我们可以得出结论,block并不会捕获全局变量。
总结：

变量类型 是否捕获到block内部 访问方式
局部变量auto 是 值传递
局部变量static 是 指针传递
全局变量 否 直接访问

思考 为什么对于不同类型的变量，block的处理方式不同呢？
这是由变量的生命周期决定的。对于自动变量，当作用域结束时，会被系统自动回收，而block很可能是在超出自动变量作用域的时候去执行，如果之前没有捕获自动变量，那么后面执行的时候，自动变量已经被回收了，得不到正确的值。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值，这样可以获得变量的最新的值。而对于全局变量，在任何位置都可以直接读取变量的值。

5.变量捕获-self变量

直接上代码:

@implementation Person

- (void)test{
    void(^block)(void) = ^{
        NSLog(@"%@", self);
    };
    
    block();
}

@end

这个Person类中只有一个东西，就是test这个函数，那么这个block有没有捕获self变量呢？
要搞清这个问题，我们只需要知道搞清楚这里self变量是局部变量还是全局变量，如果是局部变量，那么是一定会捕获的，而如果是全局变量，则一定不会被捕获。
我们把这个Person.m文件转化为c++的源码，然后找到test函数在c++中的表示：

static void _I_Person_test(Person * self, SEL _cmd) {
    void(*block)(void) = ((void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344));

    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}

我们可以看到，本来Person.m中，这个test函数我是没有传任何参数的，但是转化为c++的代码后，这里传入了两个参数，一个是self参数，一个是_cmd。self很常见，_cmd表示test函数本身。所以我们就很清楚了，self是作为参数传进来，也就是局部变量，那么block应该是捕获了self变量，事实是不是这样呢？我们只需要查看一下_Person_test_block_impl_0的结构就可以知道了。
_Person_test_block_impl_0的结构：

struct __Person__test_block_impl_0 {
  struct __block_impl impl;
  struct __Person__test_block_desc_0* Desc;
  Person *self;
  __Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
可以看到，self确实是作为成员变量被捕获了。

6.Block的类型

前面已经说过了，Block的本质就是一个OC对象，既然它是OC对象，那么它就有类型。
在搞清楚Block的类型之前，先把ARC关掉，因为ARC帮我们做了太多的事，不方便我们观察结果。关掉ARC的方法在Build Settings里面搜索Objective-C Automatic Reference Counting，把这一项置为NO。

5-1MRC捕获变量
int b = 10;
- (void)test{
    int a = 10;
    void (^block)(void) = ^{
        NSLog(@"%d %d", b, a);
    };
    NSLog(@"\n %@\n %@\n %@", [[block class] superclass], [[[block class] superclass] superclass], [[[[block class] superclass] superclass] superclass]);
}

上面的代码的打印结果是：

 __NSStackBlock
 NSBlock
 NSObject

这说明上面定义的这个block的类型是NSStackBlock，并且它最终继承自NSObject,也说明Block的本质是OC对象。

5-2MRC不捕获变量

再看一下没有捕获局部变量的block

- (void)test{
    void (^block)(void) = ^{
        NSLog(@"test");
    };
    NSLog(@"\n %@\n %@\n %@", [[block class] superclass], [[[block class] superclass] superclass], [[[[block class] superclass] superclass] superclass]);
}

上面的代码的打印结果是：

 __NSGlobalBlock
 NSBlock
 NSObject

接下来切换回ARC模式,再次打印以上两次结果:

5-1MRC捕获变量修改为ARC以后打印结果为:
  __NSMallocBlock
 NSBlock
 NSObject
5-2MRC不捕获变量修改为ARC以后打印结果为:
  __NSGlobalBlock
 NSBlock
 NSObject
5-3不论是ARC还是MRC下手动copy
void (^block)(void) = [^{
        NSLog(@"test");
    } copy];

结果如下:

  __NSGlobalBlock
 NSBlock
 NSObject
由此可见Block有三种类型，分别是NSGlobalBlock,NSMallocBlock,NSStackBlock。

这三种类型的Block对象的存储区域如下：

类 对象的存储域
NSStackBlock 栈
NSGlobalBlock 程序的数据区域(.data区)
NSMallocBlock 堆

截获了自动变量的Block是NSStackBlock类型，没有截获自动变量的Block则是NSGlobalBlock类型,NSStackBlock类型的Block进行copy操作之后其类型变成了NSMallocBlock类型。

Block的类型 副本的配置存储域 复制效果
NSStackBlock 栈 从栈复制到堆
NSGlobalBlock 程序的数据区域(.data区) 什么也不做
NSMallocBlock 堆 引用计数增加

下面我们一起分析一下NSStackBlock类型的Block进行copy操作后Block对象从栈复制到了堆有什么道理，我们首先来看一段代码：

此时环境为MRC
void (^block)(void);
void test() {
    int age = 10;
    block = ^{
        NSLog(@"age=%d", age);
    };
}

int main(int argc, char * argv[]) {
    @autoreleasepool {
        test();
        block();
        return 0;
    }
}

不出意外的话，打印结果应该是10，那么结果是不是这样呢？我们打印看一下：

2019-02-19 13:43:29.705085+0800 Test[4256:623794] age=-436931384

很奇怪，打印了一个这么奇怪的数字。这是为什么呢？
block使用了自动变量age，所以它是NSStackBlock类型的，因此block是存放在栈区，age是被捕获作为结构体的成员变量，其值也是被保存在栈区。所以当test这个函数调用完毕后，它栈上的东西就有可能被销毁了，一旦销毁了，age值就不确定是多少了。通过打印结果也可以看到，确实是影响到了block的执行。
如果我们对block执行copy操作，结果会不会不一样呢？

void (^block)(void);
void test() {
    int age = 10;
    block = [^{
        NSLog(@"age=%d", age);
    } copy];
}

int main(int argc, char * argv[]) {
    @autoreleasepool {
        test();
        block();
        return 0;
    }
}

打印结果：

2019-02-19 13:45:19.065669+0800 Test[4312:632135] age=10

这个时候得出了正确的输出。
因为对block进行copy操作后，block从栈区被复制到了堆区，它的成员变量age也随之被复制到了堆区，这样test函数执行完之后，它的栈区被销毁并不影响block，因此能得出正确的输出。

7.ARC环境下自动为Block进行copy操作

因为在ARC环境下编译器为我们做了很多copy操作。其中有一个规则就是如果Block被强指针指着，那么编译器就会对其进行copy操作。我们看到这里：

 ^{
        NSLog(@"age=%d", age);
    };

这个Block块是被强指针指着，所以它会进行copy操作，由于其使用了自动变量，所以是栈区的Block。经过复制以后就到了堆区，这样由于Block在堆区，所以就不受Block执行完成的影响，随时可以获取age的正确值。

总结一下ARC环境下自动进行copy操作的情况一共有以下几种：

1.block作为函数返回值时。
2.将block赋值给__strong指针时。
3.block作为Cocoa API中方法名含有usingBlock的方法参数时。
4.GCD中的API。

block作为函数返回值时
typedef void(^Block)(void);
Block test() {
    int age = 10;
    return ^{
        NSLog(@"age=%d", age);
    };
}

int main(int argc, char * argv[]) {
    @autoreleasepool {
        Block block = test();
        block();
        return 0;
    }
}

test函数的返回值是一个block，那这种情况的时候，在栈区的

^{
        NSLog(@"age=%d", age);
    };

这个block会被复制到堆区

将block赋值给强指针时

7中第一个例子就是将block赋值给强指针时，进行了copy操作的情况。

block作为Cocoa API中方法名含有usingBlock的方法参数时

比如说遍历数组的函数：

NSArray *array = [[NSArray alloc] init];
    [array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {            NSLog(@"%d", idx);
    }];

enumerateObjectsUsingBlock:这个函数中的block会进行copy操作

GCD中的API

GCD中的很多API的参数都有block，这个时候都会对block进行一次copy操作，比如下面这个dispatch_after函数：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{            
            NSLog(@"wait");
        });

下一篇 __weak、__strong、__block修饰Block的内部实现原理

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

推荐阅读更多精彩内容

  • 2018-06-11
    mean to add the formatted="false" attribute?.[ 46% 47325/...
    ProZoom阅读 2,615评论 0赞 3
  • iOS学习之深入理解程序编译过程
    iOS学习之深入理解程序编译过程 https://juejin.im/post/5a352bb0f265da433...
    111浪子111阅读 1,599评论 0赞 2
  • 深入剖析 iOS 编译 Clang / LLVM
    http://www.starming.com/index.php?v=index&view=107 http:/...
    111浪子111阅读 3,023评论 0赞 11
  • 心灵篇
    大道行。四维时空宇宙法，穿梭宇宙间。会有五维时空宇宙法，三维空间，二维时间，主宰世事变迁；有六维时空宇宙法。三维空...
    圣海乾坤阅读 148评论 0赞 0
  • 生之不易
    前几日，在朋友圈看到一位研究生同学辞了家人眼里的那份社会地位不错，薪水不错，前途不错的令人欣羡的工作，原因是干得心...
    彩英cherish阅读 253评论 0赞 0