block 有什么意義，特點等等，這些東西，實在是太復雜了，這里只是簡單的總結一下block的內存管理。而且也僅僅限於objective-C的部分
Block memory
block 的內存管理，應該是最頭疼的地方,就用這個來自WWDC的例子來解釋一下吧。
當程序運行到這里時，stack 空間中有 shared 變量和 captured 變量。
這里可以看出，__block 變量開始是處於stack上的。
當程序運行到這里時，stack 空間中有 shared 變量，captured 變量和block1。
這里可以看出，block 類型的變量開始時也是處在stack上的。
當程序運行到這里時，stack 空間中有 shared 變量，captured 變量和block1。
這里值得注意的就是當我們直接修改stack 上的captured變量時，block1中的captured變量仍然是原來的數值10。事實上，從const 我們就可以看出，block1中的captured變量是不能被修改的而且是從stack原有變量的一個const 拷貝。在block1中訪問的captured變量是const拷貝的，也就是說block1中captured = 10，而不是原有的stack上的值 20。當然，在block1中，我們也不能修改captured變量。
Copy block
block在一開始是處在stack上的，這是為了考慮到效率的原因，但是，有時候是需要block的生命周期長於一開始的stack，這時，我們就通過copy block 來將block復制到heap。
當程序執行完 block2 = [block1 copy];時，__block 類型變量shared，被復制到了heap中，很顯然，shared變量需要被block和block2共享(當然還有stack也要共享)，而block2被移動到heap中，很可能生命周期會長於stack，所以，shared也被復制到了heap中。而block2中的captured 也被復制到了heap中。
當程序執行完 block3 = [block2 copy];時, 我們看到的是，block2 和block3 其實指向的是同一片內存空間。事實上，block的數據結構中，保存了引用計數，而對於copy到heap中的block 再copy時，行為同普通對象retain一樣，會使引用計數+1。那么如果我們對[block retain]會如何呢？ 實際上什么都沒有發生，至少在現在的runtime版本下。因為retain中，不僅有引用計數+1在，而且retain的返回值，必須同返回調用對象的地址一樣，而block的地址是可能變化的（stack or heap），所以，這里retain的行為幾乎是被忽略掉的。
當heap中的block變量先於stack被銷毀時，如調用 [block2 release]; [block3 release];，heap中的block2，block3 由於引用計數為0 而被銷毀，而 __block 變量shared則還在heap中，因為stack還要使用，block1 也要使用。
當heap中的block變量晚於stack時，顯然，stack 被清除，function中也啥都沒了。
最后，當block2 和block3 都被release之后。則恢復到最初狀態
block details
當我們寫出一個Block literal expression
^ { 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，也可以直接這里去看。