老生常谈之Block

前面有一篇介绍Block的博客，主要介绍了Block的简单使用技巧。这篇博客主要更加深入地了解一下Block。包括：Block的实现、__Block的原理以及Block的存储域三方面。

Block的实现

首先我们使用Xcode创建一个Project,点击File-->New-->Project，选择macOS中Application的Command Line Tool，然后设置Project Name即可。你好发现这个工程值包含了一个main.m文件，然后我们做如下更改（更改后的代码如下）：

#import <stdio.h>
int main(int argc, const char * argv[]) {
    printf("Hello World");
    return 0;
}

这个是我们最常见的C代码，导入stdio.h，然后打印出来Hello World。接下来我们写一个最简单的block，没有返回值，没有传入参数：

#import <stdio.h>
int main(int argc, const char * argv[]) {
    void (^blk)(void) = ^{
        printf("Hello Worldddd");
    };
    blk();
    return 0;
}

打印出来的结果相当于调用了blk输出的结果。接下来我们在item中跳转到main.m所在文件夹然后执行如下命令：

clang -rewrite-objc main.m

你会发现在当前文件夹下生成了一个.cpp文件，它是经过clang编译器编译之后的文件，打开之后里面大概有5百多行，其实我们看下面的这些代码就足够了：

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;
  }
};
#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
        printf("Hello Worldddd");
    }
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[]) {
    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_impl、__main_block_desc_0

和两个方法：

__main_block_func_0、main

main就是我们写的main函数。

至此，你能知道的就是：Block看上去很特别，其实就是作为及其普通的C语言源代码来处理的。编译器会把Block的源代码转换成一般的C语言编译器能处理的源代码，并作为极为普通的C语言源代码被编译。

接下来对编译的内容来一个分解，首先是

^{printf("Hello Worldddd")};

变换后的源代码如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
        printf("Hello Worldddd");
    }

也就是现在变成了一个静态方法，其命名方式为：Block所属的函数名(main)和该Block语法在函数出现的顺序值(0)来给经过clang变换的函数命名。该方法的参数相当于我们在OC里面的指向自身的self。我们看一下该参数的声明：

struct __main_block_impl_0 *__cself

你会发现它其实是一个结构体，该结构体的声明如下：

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

该结构体中你会发现里面有一个构造函数，你忽略构造函数，会发现该结构体就很简单了，只是包含了impl和 Desc两个属性变量。其中impl也是一个结构体，它的结构如下：

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

从属性变量的名字我们可以猜测出该结构体各个属性的含义：

isa：isa指针，指向父类的指针。
Flags：一个标记
Reserved：预留区域，用于以后的使用。
FuncPtr：这个很重要，是一个函数指针。后面会详细说明它的作用。

第二个变量是Desc，也是一个结构体：

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

这个结构体就比较简单了，一个预留位，一个是指代该Block大小的属性，后面又包含了一个该实例：

__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

预留位为0，大小为传入结构体的大小。接下来就是很重要的构造函数了：

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

其中的&_NSConcreteStackBlock用于初始化impl的isa指针；flags为0；FuncPtr是构造函数传过来的fp函数指针；Desc为一个block的描述。到这里三个结构体和一个函数就介绍完了。接下来看一下main函数里面上述构造函数是如何调用的：

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

感觉好复杂，我们先做一个转换：

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

也就是说把结构体的实例的指针赋值给blk。接下来再看一下构造函数的的初始化，其实赋值就变成了这样：

impl.isa = &_NSConcreteStackBLock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;

现在在看一下调用block的那句代码：

blk();

转换成了：

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

这个转换不是太明白，但是知道他的作用就是把blk当做参数传进去，调用的FuncPtr所指向的函数，也就是__ block _ block _ func _ 0。

到这里就大体了解了Block的实现，其实就是C的几个结构体和方法，经过赋值和调用，进而实现了Block。

另外Block其实实质上也是OC的对象。

__Block的原理

先看一个简单的例子：

#import <stdio.h>
int main(int argc, const char * argv[]) {
    int i = 3;
    void (^blk)(void) = ^{
        printf("Hello World,%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("Hello World,%d",i);
    }
int main(int argc, const char * argv[]) {
    int i = 3;
    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函数调用的时候把i传到了构造函数里，然后通过i(_i)对结构体的属性变量i赋值，i变量现在已经成为了结构体的一个树形变量。在构造函数执行时把i赋值。在 __ main _ block_func _ 0里面通过 __ cself调用，这个变量实际是在声明block时，被复制到了结构体变量i，因此不会影响变量i的值。当我们尝试在Block中去修改时，你会得到如下错误：

Variable is not assignable(missing __block type specifier)

提示我们加上__block,接下来我们将源代码做如下修改：

int main(int argc, const char * argv[]) {
    __block int i = 3;
    void (^blk)(void) = ^{
        i = i + 3;
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

运行一下你会发现你成功对i的值进行了修改！用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) = (i->__forwarding->i) + 3;
        printf("Hello World,%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(int argc, const char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 3};
    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的结构体，然后多了两个copy和dispose函数。

看一下main函数里面的i，此时也不再是一个简单的基本类型int，而是一个初始化的 __ Block _ byref _ i _ 0的结构体，该结构体有个属性变量为i，然后把3赋值给了那个属性变量。该结构体还有一个指向自己的指针 __ forwarding，它被赋值为i的地址。

现在 __ main _ block _ func _ 0在实现中使用了指向该变量的指针，所以达到了修改外部变量的作用。

Block的存储域

Block的存储域有以下几种：

_ NSConcreteStackBlock,该类的对象Block设置在栈上
_ NSConcreteGlobalBlock,该类的Block设置在程序的数据区(.data)域中。
_ NSConcreteMallocBlcok,该类的Block设置在堆上

下面这张图展示了Block的存储域:

我们前面看到的都是在Stack的Block，但是你可以在OC工程中打印一下你声明的block的isa，你会发现它其实是Malloc的block，也就是在堆上的block。如图：

还有一种情况是Global的block：

在ARC中，只有NSConcreteGlobalBlock和NSConcreteMallockBlock两种类型的block。因为我们最简单的block在工程中打印出来的都是MallocBlock。也许是因为苹果把对象都放到了堆管理，而Block也是对象，所以也放到了堆上。

此时我们也许会有个疑问：Block超出了变量作用域为什么还能存在呢？

对于Global的Block，变量作用域之外也可以通过指针安全使用，但是设置在栈上的就比较尴尬了，作用域结束后，Block也会被废弃。为了使Block超出变量作用域还可以存在，Block提供了将Block和 __ block变量从栈上复制到堆上的方法来解决这个问题。这样就算栈上的废弃，堆上的Block还可以继续存在。

看一下对Block进行复制，结果如何：

如果对Block进行了copy操作，__ block的变量也会受到影响，当 __ block的变量配置在栈上，复制之后它将从栈复制到堆上并被Blcok持有，如果是堆上的 __ block变量，Blcok复制之后该变量被Block持有。

如果两个block（block1,block2）同时都是用 __ block变量，如果block1被复制到了堆上，那么 __ block变量也会在block1复制到堆的同时复制到堆上，当block2再是用到 __ block变量的时候，只是增加堆上 __ block变量的引用计数，不会再次复制。如果堆上的block1和block2被废弃了，那么它所是用的 __ block变量也就被释放了（如果block1被废弃，而block2没有被废弃，那么 __ block变量的引用计数-1，直到最后使用 __ block变量的block被废弃的同时，堆上的 __ block也会被释放）。

理解了上面刚才说的复制之后，现在回过来思考另一个问题： __ block的时候转换的结构体中的 __ forwarding指针有什么作用呢？（下面代码中的 __ forwarding）

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

其实是这样的：栈上的 __ block变量用结构体实例在 __ block变量从栈复制到堆上的时候，会将成员变量 __ forwarding的值替换为复制目标堆上的 __ block变量用结构体实例的地址。通过该操作之后，无论是在Block语法中、Block语法外使用 __ block变量，还是 __ block变量配置在栈上或者堆上，都可以顺利地访问同一个 __ block变量。

以上便是对block的进一步介绍，主要参考了《Objective-C高级编程 iOS与OS X多线程和内存管理》一书。

转载请标明来源：http://www.cnblogs.com/zhanggui/p/8135790.html