objc block是如何实现的

Objective-C中引入的Block给代码的编写以及多线程的处理带来了很多方便,但它是如何实现的呢?可以借助clang的–rewrite-objc来揭开她的面纱。

因为下面的代码会涉及一点c++ 在揭开之前先说一点c++的简单知识。
struct在c++中与class一样都是声明一个类,但struct中默认都声明为public。既然是个类struct就可以有自己的构造函数。

struct Foo{
  int bar;
  Foo(int _bar) {
    bar = _bar
  };
}
Foo f = Foo(1);
int x = f.bar;

这里Foo(int _bar)就是Foo的构造函数,与objc中的init类似。

关于struct的说明就这些,以下把struct都叫类, 下面来看block

看一段代码,给hi赋值了一个打印”hello!”的block,然后调用它

#import 
int main()
{
	void (^hi)(int a) = ^(int a){printf("hello %d\n", a);};
	hi(1);
	return 0;
}

使用clang -rewrite-objc test.m得到test.cpp, 看下转化后的代码, 这里省去部分无关的代码。

# 2 "test.m" 2

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

#line 4 "test.m"
static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a) {
printf("hello %d\n", a);}

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

#line 2 "test.m"
int main()
{
 void (*hi)(int a) = (void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
 ((void (*)(__block_impl *, int))((__block_impl *)hi)->FuncPtr)((__block_impl *)hi, 1);
 return 0;
}

我们看到之前的代码变成了下面的样子

 void (*hi)(int a) = (void (*)(int))&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
 ((void (*)(__block_impl *, int))((__block_impl *)hi)->FuncPtr)((__block_impl *)hi, 1);

看到hi()的调用实际是调用了hi->FuncPtr所指向的函数并把hi和原来的能数作为参数列表。
那么FuncPtr指向了哪个函数呢,从__main_block_impl_0的构造函数和hi的创建可以看到FuncPtr指到了__main_block_func_0。下面看一下__main_block_func_0的实现

static void __main_block_func_0(struct __main_block_impl_0 *__cself, int a) {
printf("hello %d\n", a);
}

这里就是之前写的block里面的内容,那么这里为什么会把block自己传递进来了,这个后面再看。

到此为至,看到了之前写的block的内容会变成一个c函数,原来引用的block的变量会指向到一个__main_block_impl_0的实例上。__main_block_impl_0会有一个指针指向到变成的c函数上。

block有个特点是可以抓住block外的变量,比如下面这段代码:

#import 
int main()
{
	int foo = 1;
	void (^hi)() = ^{printf("hello! %d\n", foo);};
	hi();
	return 0;
}

rewrite后

# 2 "test1.m" 2

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

#line 5 "test1.m"
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int foo = __cself->foo; // bound by copy
printf("hello! %d\n", foo);}

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

#line 2 "test1.m"
int main()
{
 int foo = 1;
 void (*hi)() = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, foo);
 ((void (*)(__block_impl *))((__block_impl *)hi)->FuncPtr)((__block_impl *)hi);
 return 0;
}

对比之前的代码,发现block实例化的时候把foo这个变量传递了进去并保存在block的实例中,在block对应的函数中,我们看到了如何使用这个变量

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

所以block的外部变量引用是在初始化的时候会把变量拷贝一份到block实例中,在block调用时,再使用这一份拷贝的数据。

block还有一个功能修改一个外部变量的值,即用__block修饰的变量,再来看一段示例代码

#import 
#import 
int main()
{
   	__block int foo = 1;
	void (^hi)() = ^{foo=2;};
	hi();
	printf("foo: %d\n", foo);
	return 0;
}

clang test2.m -lobjc -rewrite-objc

# 2 "test2.m" 2
struct __Block_byref_foo_0 {
  void *__isa;
__Block_byref_foo_0 *__forwarding;
 int __flags;
 int __size;
 int foo;
};

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

#line 5 "test2.m"
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_foo_0 *foo = __cself->foo; // bound by ref
(foo->__forwarding->foo)=2;}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->foo, (void*)src->foo, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

#line 2 "test2.m"
int main()
{
    __attribute__((__blocks__(byref))) __Block_byref_foo_0 foo = {(void*)0,(__Block_byref_foo_0 *)&foo, 0, sizeof(__Block_byref_foo_0), 1};
 void (*hi)() = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_foo_0 *)&foo, 570425344);
 ((void (*)(__block_impl *))((__block_impl *)hi)->FuncPtr)((__block_impl *)hi);
 printf("foo: %d\n", (foo.__forwarding->foo));
 return 0;
}

这次变化略大,还是从main开始看。
原来的foo从int变成了__Block_byref_foo_0, 其它的调用与之前差不多,注意到后面对foo的操作都是在修改或获取foo.__forwarding->foo。

看一下__Block_byref_foo_0的定义,

struct __Block_byref_foo_0 {
  void *__isa;
 __Block_byref_foo_0 *__forwarding;
 int __flags;
 int __size;
 int foo;
};

和实例化所使用的方法

__Block_byref_foo_0 foo = {(void*)0,(__Block_byref_foo_0 *)&foo, 0, sizeof(__Block_byref_foo_0), 1}

注意到这里的__forwading引用了foo也就是其自身, 为什么要这样做呢,为了在block copy到堆后可以修改block外的变量。

从上面的代码可以看到block的创建是在栈上,如果一旦函数结束foo和block就会被释放掉,所以需要在作用域外使用block时会对block做一次copy操作,把block从栈拷贝到堆上,拷贝完成后foo.__forwarding会指向堆里的foo这样,堆中的foo.__forwarding指向自身,后面需对foo的操作都会对堆中的内存进行修改,即使作用域结束栈中的变量无效,也能正常对__block修饰的变量进行读写了。

简单的介绍了一下block的原理与automatic variable capturing的原理. 再看下下面几个会出现异常的代码。

typedef void (^blk_t)(void);
blk_t createBlock(void) {
  int a = 1;
  return ^{ printf("a: %d\n", a);}
}

int main(int argc, char **argv) {
  createBlock()();
  return 0;
}

这段代码在非arc下运行时会出问题。因为a在createBlock后被干掉了,如果声明为__block int a是否会出问题呢?感兴趣的盆友可以自行验证一下。