objc 中的 block

妖狐艹你老母 2022-06-16 13:28 143阅读 0赞

1.block的数据结构

首先，关于block的数据结构和runtime是开源的，可以在[llvm项目][llvm]看到，或者下载苹果的[libclosure][]库的源码来看。苹果也提供了[在线的代码查看][Link 1]方式，其中包含了很多示例和文档说明。

这两个地方的定义是相同的：

structBlock\_descriptor\_1\{

uintptr\_treserved;

uintptr\_tsize;

\};

structBlock\_layout\{

void\*isa;

volatileint32\_tflags;// contains ref count

int32\_treserved;

void(\*invoke)(void\*,...);

structBlock\_descriptor\_1\*descriptor;

// imported variables

\};

在objc中，根据对象的定义，凡是首地址是\*isa的结构体指针，都可以认为是对象(id)。这样在objc中，block实际上就算是对象。

为了查看编译器具体的工作，这里可以用clang重写一段代码试试看：

voidfoo\_()\{

inti=2;

NSNumber\*num=@3;

long(^myBlock)(void)=^long()\{

returni\*num.intValue;

\};

longr=myBlock();

上面这是一个很简单的block，捕获了两个变量：一个int，一个NSNumber。

用clang翻译成C++后变出了一大坨代码，看着别扭不贴上来了。为了方便理解，这里稍微简化和调整一下：

struct\_\_block\_impl\{

void\*isa;

intFlags;

intReserved;

void\*FuncPtr;

\};

struct\_\_foo\_block\_desc\_0\{

size\_treserved;

size\_tBlock\_size;

void(\*copy)(struct\_\_foo\_block\_impl\_0\*,struct\_\_foo\_block\_impl\_0\*);

void(\*dispose)(struct\_\_foo\_block\_impl\_0\*);

\};

//myBlock的数据结构定义

struct\_\_foo\_block\_impl\_0\{

struct\_\_block\_implimpl;

struct\_\_foo\_block\_desc\_0\*Desc;

inti;

NSNumber\*num;

\};

//block数据的描述

staticstruct\_\_foo\_block\_desc\_0\_\_foo\_block\_desc\_0\_DATA=\{

sizeof(struct\_\_foo\_block\_impl\_0),

\_\_foo\_block\_copy\_0,

\_\_foo\_block\_dispose\_0

\};

//block中的方法

staticlong\_\_foo\_block\_func\_0(struct\_\_foo\_block\_impl\_0\*\_\_cself)\{

inti=\_\_cself->i;// bound by copy

NSNumber\*num=\_\_cself->num;// bound by copy

returni\*num.intValue;

voidfoo()\{

inti=2;

NSNumber\*num=@3;

struct\_\_foo\_block\_impl\_0myBlockT;

struct\_\_foo\_block\_impl\_0\*myBlock=&myBlockT;

myBlock->impl.isa=&\_NSConcreteStackBlock;

myBlock->impl.Flags=570425344;

myBlock->impl.FuncPtr=\_\_foo\_block\_func\_0;

myBlock->Desc=&\_\_foo\_block\_desc\_0\_DATA;

myBlock->i=i;

myBlock->num=num;

longr=myBlock->impl.FuncPtr(myBlock);

编译器会根据block捕获的变量，生成具体的结构体定义。block内部的代码将会提取出来，成为一个单独的C函数。创建block时，实际就是在方法中声明一个struct，并且初始化该struct的成员。而执行block时，就是调用那个单独的C函数，并把该struct指针传递过去。

block中包含了被引用的自由变量(由struct持有)，也包含了控制成分的代码块(由函数指针持有)，符合闭包(closure)的概念。

2.block的Copy

block中的isa指向的是该block的Class。在block runtime中，定义了6种类：

\_NSConcreteStackBlock     栈上创建的block

\_NSConcreteMallocBlock  堆上创建的block

\_NSConcreteGlobalBlock   作为全局变量的block

\_NSConcreteWeakBlockVariable

\_NSConcreteAutoBlock

\_NSConcreteFinalizingBlock

其中我们能接触到的主要是前3种，后三种用于GC不再讨论..

上面代码可以看到，当struct第一次被创建时，它是存在于该函数的栈帧上的，其Class是固定的\_NSConcreteStackBlock。其捕获的变量是会赋值到结构体的成员上，所以当block初始化完成后，捕获到的变量不能更改。

当函数返回时，函数的栈帧被销毁，这个block的内存也会被清除。所以在函数结束后仍然需要这个block时，就必须用Block\_copy()方法将它拷贝到堆上。这个方法的核心动作很简单：申请内存，将栈数据复制过去，将Class改一下，最后向捕获到的对象发送retain，增加block的引用计数。详细代码可以直接[点这里][Link 2]查看。

structBlock\_layout\*result=malloc(aBlock->descriptor->size);

memmove(result,aBlock,aBlock->descriptor->size);

result->isa=\_NSConcreteMallocBlock;

\_Block\_call\_copy\_helper(result,aBlock);

returnresult;

3.\_\_block类型的变量

默认block捕获到的变量，都是赋值给block的结构体的，相当于const不可改。为了让block能访问并修改外部变量，需要加上\_\_block修饰词。

举个例子：

voidfoo()\{

\_\_blockinti=3;

void(^myBlock)(void)=^\{

i\*=2;

\};

myBlock();

让clang重写一下：

structBlock\_byref\{//Block\_private.h中的定义

void\*isa;

structBlock\_byref\*forwarding;

volatileint32\_tflags;// contains ref count

uint32\_tsize;

\};

//\_\_block count的实现

struct\_\_Block\_byref\_count\_0\{

void\*\_\_isa;

\_\_Block\_byref\_count\_0\*\_\_forwarding;

int\_\_flags;

int\_\_size;

intcount;

\};

voidfoo\_()\{

\_\_attribute\_\_((\_\_blocks\_\_(byref)))\_\_Block\_byref\_count\_0count=\{(void\*)0,(\_\_Block\_byref\_count\_0\*)&count,0,sizeof(\_\_Block\_byref\_count\_0),1\};

void(\*myBlock)(void)=(void(\*)())&\_\_foo\_\_block\_impl\_0((void\*)\_\_foo\_\_block\_func\_0,&\_\_foo\_\_block\_desc\_0\_DATA,(\_\_Block\_byref\_count\_0\*)&count,570425344);

((void(\*)(\_\_block\_impl\*))((\_\_block\_impl\*)myBlock)->FuncPtr)((\_\_block\_impl\*)myBlock);

哗～一下子变出来一坨东西。就因为加了个\_\_block，原本的int值的位置变成了一个struct（struct \_\_Block\_byref）。这个struct的首地址为同样为\*isa。

正是如此，这个值才能被block共享、并且不受栈帧生命周期的限制、在block被copy后，能够随着block复制到堆上。

4.使用注意事项

block对变量的捕获规则：

1.静态存储区的变量：例如全局变量、方法中的static变量

引用，可修改。

2.block接受的参数

传值，可修改，和一般函数的参数相同。

3.栈变量 (被捕获的上下文变量)

const，不可修改。 当block被copy后，block会对 id类型的变量产生强引用。

每次执行block时,捕获到的变量都是最初的值。

4.栈变量 (有\_\_block前缀)

引用，可以修改。如果时id类型则不会被block retain,必须手动处理其内存管理。

如果该类型是C类型变量，block被copy到heap后,该值也会被挪动到heap

注意1.内存

Block\_copy()和Block\_release()必须一一匹配，否则会内存泄漏或crash。

\_\_block这个修饰词会将原本的简单类型转化为较大的struct，这会给内存、调用带来额外的开销，使用时需要注意。

注意2.ARC

在开启ARC后，block的内存会比较微妙。ARC会自动处理block的内存，不用手动copy/release。

但是，和非ARC的情况有所不同：

2void(^aBlock)(void);

aBlock=^\{printf("ok");\};

block是对象，所以这个aBlock默认是有\_\_strong修饰符的，即aBlock对该block有strong references。即aBlock在被赋值的那一刻，这个block会被copy。所以，ARC开启后，所能接触到的block基本都是在堆上的。。

void(^aBlock)(void)=nil;

if(!aBlock)\{

aBlock=^\{printf("hehe");\};

//block此时block已经被释放,该处留下了一个dangling pointer

aBlock();

上面这个例子，如果是非ARC时，block还在栈帧上，所以没问题。但开启ARC后，block会被先copy到堆上，然后再被释放，这里就会crash了。所以这时就必须手动调用Block\_copy了。苹果建议尽量避免这种情况。

注意3.循环引用

当block被copy之后(如开启了ARC、或把block放入dispatch queue)，该block对它捕获的对象产生strong references (非ARC下是retain),

所以有时需要避免block copy后产生的循环引用。

如果用self引用了block，block又捕获了self，这样就会有循环引用。

因此，需要用weak来声明self

\-(void)configureBlock\{

XYZBlockKeeper\*\_\_weakweakSelf=self;

self.block=^\{

\[weakSelfdoSomething\];//捕获到的是弱引用

如果捕获到的是当前对象的成员变量对象，同样也会造成对self的引用，同样也要避免。

\-(void)configureBlock\{

idtmpIvar=\_ivar;//临时变量,避免了self引用

self.block=^\{

\[tmpIvarmsg\];

为了避免循环引用，可以这样理解block：block就是一个对象，它捕获到的值就是这个对象的@property(strong)。这样在遇到问题时，就能迅速确定是否有循环引用了。Xcode5已经能自动发现这种问题了，不错～

[llvm]: https://llvm.org/svn/llvm-project/compiler-rt/trunk/BlocksRuntime/
[libclosure]: http://www.opensource.apple.com/tarballs/libclosure/
[Link 1]: http://opensource.apple.com/source/libclosure/libclosure-63/
[Link 2]: http://opensource.apple.com/source/libclosure/libclosure-63/runtime.c