Objective-C block，objective-cblock

Objective-C block，objective-cblock

block 有什么意义，特点等等，这些东西，实在是太复杂了，这里只是简单的总结一下block的内存管理。而且也仅仅限于objective-C的部分

Block memory

block 的内存管理，应该是最头疼的地方,就用这个来自WWDC的例子来解释一下吧。

^ { printf("hello world\n"); }

事实上，编译器为我们生成了如下结构

struct __block_literal_1 {

    void *isa;

    int flags;

    int reserved; 

    void (*invoke)(struct __block_literal_1 *);

    struct __block_descriptor_1 *descriptor;

};void __block_invoke_1(struct __block_literal_1 *_block) {

    printf("hello world\n");

}static struct __block_descriptor_1 {

    unsigned long int reserved;

    unsigned long int Block_size;

} __block_descriptor_1 = { 0, sizeof(struct __block_literal_1)}; 当Block literal expression 使用时 __block_literal_1 则会被初始化为：struct __block_literal_1 _block_literal = {

    &_NSConcreteStackBlock,

    (1<<29), <uninitialized>,

    __block_invoke_1,

    &__block_descriptor_1

   };

下一个例子

int x = 10;

void (^vv)(void) = ^{printf("x is %d\n", x);};

x = 11;

vv();

编译器会生成如下结构

struct __block_literal_2{

    void *isa;

    int flags;

    int reserved;

    void (*invoke)(struct __block_literal_2 *);

    struct __block_descriptor_2 *descriptor;

    const int x;

};

void __block_invoke_2(struct __block_literal_2 *_block){

    printf("x is %d\n", _block->x);

}

void struct __block_descriptor_2{

    unsigned long int reserved;

    unsigned long int block_size;

}__block_descriptor_2 = {0, sizeof(struct __block_literal_2)};

struct __block_literal_2 __block_literal_2 = {

    &NSConcreteStackBlock,

    (1<<29),

    __block_invoke_2,

    &__block_descriptor_2,

    x

};

block中使用的普通变量（int， char *）导入是const copy。普通对象则会retain。__block 类型变量则什么不做，只是保存一个指针，全局变量也只是保存一个简单的指针。

当然，block 可能也会嵌套block，那么又会是什么样子？其实不复杂，复杂的只是增加了复制函数，和释放函数，这一点很像C++的拷贝构造函数，在必要时生成。

void (^existingBlock)(void) = …;

void (^vv)(void) = ^{existingBlock();};

vv();

struct __block_literal_3{

    ...;//esisting block

};

struct __block_literal_4{

    void *isa;

    int flags;

    int reserved;

    void (*invoke)(struct __block_literal_4 *);

    struct __block_literal_3 *const existingBlock;

};

void __block_invoke_4(struct __block_literal_3 *__block) {

   __block->existingBlock->invoke(__block->existingBlock);

}

void __block_copy_4(struct __block_literal_4 *dst, struct __block_literal_4 *src) {

     //_Block_copy_assign(&dst->existingBlock, src->existingBlock, 0);

     _Block_object_assign(&dst->existingBlock, src->existingBlock, BLOCK_FIELD_IS_BLOCK);

}

void __block_dispose_4(struct __block_literal_4 *src) {

     // was _Block_destroy

     _Block_object_dispose(src->existingBlock, BLOCK_FIELD_IS_BLOCK);

}

static struct __block_descriptor_4 {

    unsigned long int reserved;

    unsigned long int Block_size;

    void (*copy_helper)(struct __block_literal_4 *dst, struct __block_literal_4 *src);

    void (*dispose_helper)(struct __block_literal_4 *);

} __block_descriptor_4 = {

    0,

    sizeof(struct __block_literal_4),

    __block_copy_4,

    __block_dispose_4,

};

初始化

  struct __block_literal_4 _block_literal = {

    &_NSConcreteStackBlock,

    (1<<25)|(1<<29), <uninitialized>

    __block_invoke_4,

    & __block_descriptor_4

        existingBlock,

   };

 

__block storage variables

__block  变量是一种很特殊的数据类型，有自己的特有的数据结构

struct _block_byref_xxxx {

    void *isa;

    struct _block_byref_xxxx *forwarding;

    int flags;   //refcount;

    int size;

    // helper functions called via Block_copy() and Block_release()

    void (*byref_keep)(void  *dst, void *src); //需要时被生成

    void (*byref_dispose)(void *);//需要时被生成

    typeof(marked_variable) marked_variable;

};

看看__block 类型变量的使用

int __block i = 10;

i = 11;

struct _block_byref_i {

    void *isa;

    struct _block_byref_i *forwarding;

    int flags;   //refcount;

    int size;

    int captured_i;

} i = { NULL, &i, 0, sizeof(struct _block_byref_i), 10 };

i.forwarding->captured_i = 11;

 

显然，当block中增加了__block 类型变量之后，嵌套block 的拷贝函数也会增加对__block 变量的复制。

__block void (voidBlock)(void) = blockA;

voidBlock = blockB;

struct _block_byref_voidBlock {

    void *isa;

    struct _block_byref_voidBlock *forwarding;

    int flags;   //refcount;

    int size;

    void (*byref_keep)(struct _block_byref_voidBlock *dst, struct _block_byref_voidBlock *src);

    void (*byref_dispose)(struct _block_byref_voidBlock *);

    void (^captured_voidBlock)(void);

};

void _block_byref_keep_helper(struct _block_byref_voidBlock *dst, struct _block_byref_voidBlock *src) {

    //_Block_copy_assign(&dst->captured_voidBlock, src->captured_voidBlock, 0);

    _Block_object_assign(&dst->captured_voidBlock, src->captured_voidBlock, BLOCK_FIELD_IS_BLOCK | BLOCK_BYREF_CALLER);

}

void _block_byref_dispose_helper(struct _block_byref_voidBlock *param) {

    //_Block_destroy(param->captured_voidBlock, 0);

    _Block_object_dispose(param->captured_voidBlock, BLOCK_FIELD_IS_BLOCK | BLOCK_BYREF_CALLER)}

struct _block_byref_voidBlock voidBlock = {( .forwarding=&voidBlock, .flags=(1<<25), .size=sizeof(struct _block_byref_voidBlock *),

      .byref_keep=_block_byref_keep_helper, .byref_dispose=_block_byref_dispose_helper,

      .captured_voidBlock=blockA )};

voidBlock.forwarding->captured_voidBlock = blockB;

 

block中，引入了__block 会是什么情况

int __block i = 2;

functioncall(^{ i = 10; });

struct _block_byref_i {

    void *isa;  // set to NULL

    struct _block_byref_voidBlock *forwarding;

    int flags;   //refcount;

    int size;

    void (*byref_keep)(struct _block_byref_i *dst, struct _block_byref_i *src);

    void (*byref_dispose)(struct _block_byref_i *);

    int captured_i;

};

struct __block_literal_5 {

    void *isa;

    int flags;

    int reserved; 

    void (*invoke)(struct __block_literal_5 *);

    struct __block_descriptor_5 *descriptor;

    struct _block_byref_i *i_holder;

};

void __block_invoke_5(struct __block_literal_5 *_block) {

   _block->i_holder->forwarding->captured_i = 10;

}

void __block_copy_5(struct __block_literal_5 *dst, struct __block_literal_5 *src) {

     _Block_object_assign(&dst->i_holder, src->i_holder, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);

}

void __block_dispose_5(struct __block_literal_5 *src) {

     _Block_object_dispose(src->i_holder, BLOCK_FIELD_IS_BYREF | BLOCK_BYREF_CALLER);

}

static struct __block_descriptor_5 {

    unsigned long int reserved;

    unsigned long int Block_size;

    void (*copy_helper)(struct __block_literal_5 *dst, struct __block_literal_5 *src);

    void (*dispose_helper)(struct __block_literal_5 *);

} __block_descriptor_5 = { 0, sizeof(struct __block_literal_5) __block_copy_5, __block_dispose_5 };

struct _block_byref_i i = {( .forwarding=&i, .flags=0, .size=sizeof(struct _block_byref_i) )};

struct __block_literal_5 _block_literal = {

    &_NSConcreteStackBlock,

    (1<<25)|(1<<29), <uninitialized>,

    __block_invoke_5,

    &__block_descriptor_5,

        2,

   };

 

block 中的太多细节这里不做赘述，有兴趣的可以参考Block—ABI-Apple，也可以直接这里去看。