Block是iOS開發中一種比較特殊的數據結構，它可以保存一段代碼，在合適的地方再調用，具有語法簡介、回調方便、編程思路清晰、執行效率高等優點，受到眾多猿猿的喜愛。但是Block在使用過程中，如果對Block理解不深刻，容易出現Cycle Retain的問題。本文主要從ARC模式下解析一下Block的底層實現，以及Block的三種類型（棧、堆、全局）的區別。
一、Block定義
1. Block 定義及使用
返回值類型 (^block變量名)(形參列表) = ^(形參列表) {
};
// 調用Block保存的代碼
block變量名(實參);
2. 項目中使用格式
在項目中，通常會重新定義block的類型的別名，然后用別名來定義block的類型
// 定義block類型
typedef void (^Block)(int);
// 定義block
Block block = ^(int a){};
// 調用block
block(3);
二、Block底層實現
block的底層實現是結構體，和類的底層實現類似，都有isa指針，可以把block當成是一個對象。下面通過創建一個控制臺程序，來窺探block的底層實現
1. block內存結構
block 的內存結構圖
Block_layout結構體成員含義如下：
- isa: 指向所屬類的指針，也就是block的類型
- flags: 標志變量，在實現block的內部操作時會用到
- Reserved: 保留變量
- invoke: block執行時調用的函數指針，block內部的執行代碼都在這個函數中
- descriptor: block的詳細描述，包含 copy/dispose 函數，處理block引用外部變量時使用
- variables: block范圍外的變量，如果block沒有調用任何外部變量，該變量就不存在
Block_descriptor結構體成員含義如下：
- reserved: 保留變量
- size: block的內存大小
- copy: 拷貝block中被
__block修飾的外部變量 - dispose: 和
copy方法配置應用，用來釋放資源
具體實現代碼如下（代碼來自Block_private.h）:
enum {
BLOCK_REFCOUNT_MASK = (0xffff),
BLOCK_NEEDS_FREE = (1 << 24),
BLOCK_HAS_COPY_DISPOSE = (1 << 25),
BLOCK_HAS_CTOR = (1 << 26), /* Helpers have C++ code. */
BLOCK_IS_GC = (1 << 27),
BLOCK_IS_GLOBAL = (1 << 28),
BLOCK_HAS_DESCRIPTOR = (1 << 29)
};
/* Revised new layout. */
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
2. 創建block
int main(int argc, const char * argv[]) {
@autoreleasepool {
// 最簡block
^{ };
}
return 0;
}
3. 轉換結構
利用 clang 把 *.m 的文件轉換為 *.cpp 文件，就可以看到 block 的底層實現了
$ clang -rewrite-objc main.m
轉換后的代碼：
struct __block_impl {
void *isa;
int Flags;
int Reserved;
void *FuncPtr;
};
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;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
}
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[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
(void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
}
return 0;
}
從代碼中可以看出，__main_block_impl_0就是block的C++實現（最后面的_0代表是main中的第幾個block），__main_block_func_0是block的代碼塊，__main_block_desc_0是block的描述，__block_impl是block的定義。
__block_impl成員含義如下：
- isa: 指向所屬類的指針，也就是block的類型
- flags，標志變量，在實現block的內部操作時會用到
- Reserved，保留變量
- FuncPtr，block執行時調用的函數指針
__main_block_impl_0解釋如下：
- impl: block對象
- Desc: block對象的描述
其中，__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) 這是顯式構造函數，flags的默認值為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;
}
可以看出：
- __main_block_impl_0的isa指針指向了_NSConcreteStackBlock，所有的局部block都是在棧上門創建
- 從main函數中看， __main_block_impl_0的FuncPtr指向了函數__main_block_func_0
- __main_block_impl_0的Desc也指向了定義__main_block_desc_0時就創建的__main_block_desc_0_DATA，其中Block_size記錄了block結構體大小等信息
__main_block_desc_0成員含義如下：
- reserved: 保留變量
- Block_size: block內存大小，sizeof(struct __main_block_impl_0)
三、Block類型
block有三種類型：
- _NSConcreteGlobalBlock: 存儲在全局數據區
- _NSConcreteStackBlock: 存儲在棧區
- _NSConcreteMallocBlock: 存儲在堆區
APUE的進程虛擬內存段分布圖如下：
其中，_NSConcreteGlobalBlock 和 _NSConcreteStackBlock 可以由程序創建，而 _NSConcreteMallocBlock 則無法由程序創建，只能由 _NSConcreteStackBlock 通過拷貝生成。
1. 全局block 和 棧block
測試代碼如下：
void (^globalBlock)() = ^{
};
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^stackBlock1)() = ^{
};
}
return 0;
}
clang轉換后的代碼如下：
// globalBlock
struct __globalBlock_block_impl_0 {
...
__globalBlock_block_impl_0(void *fp, struct __globalBlock_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteGlobalBlock;
...
}
};
...
// stackBlock
struct __main_block_impl_0 {
...
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
...
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
void (*stackBlock)() = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA);
}
return 0;
}
可以看出， globalBlock 的 isa 指向了 _NSConcreteGlobalBlock，即在全局區域創建，編譯時其具體代碼在代碼段中，block變量則存儲在全局數據區；而stackBlock 的 isa 則指向了 _NSConcreteStackBlock，表明在棧區創建。
2. 捕獲外部參數對棧區block結構的影響
由于堆區 block 是由棧區 block 轉化而成， 所以下面主要分析棧區 block 如何轉化為堆區 block。
捕獲局部非靜態變量
代碼：
int a = 0;
^{a;};
轉化后：
struct __Person__test_block_impl_0 {
...
int a;
// a(_a)是構造函數的參數列表初始化形式，相當于a = _a。從_I_Person_test看，傳入的就是a
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
static void _I_Person_test(Person * self, SEL _cmd) {
int a;
(void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, a);
}
可以看到，block 對于棧區變量的引用只是值傳遞，由于 block 內部變量 a 和 外部變量 a 不在同一個作用域，所以在 block 內部不能把變量 a 作為左值(left-value)，因為賦值沒有意義。所以，如果出現如下代碼，編譯器會提示錯誤：
a = 10;
捕獲局部靜態變量
代碼：
static int a;
^{
a = 10;
};
轉換后：
struct __Person__test_block_impl_0 {
...
int *a;
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
int *a = __cself->a; // bound by copy
// 這里通過局部靜態變量a的地址來對其進行修改
(*a) = 10;
}
static void _I_Person_test(Person * self, SEL _cmd) {
static int a;
// 傳入a的地址
(void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, &a);
}
由于局部靜態變量也存儲在靜態數據區，和程序擁有一樣的生命周期，但是其作用范圍局限在定義它的函數中，所有在block里是通過地址來訪問。
捕獲全局變量
代碼：
// 全局靜態
static int a;
// 全局
int b;
- (void)test
{
^{
a = 10;
b = 10;
};
}
轉換后：
static int a;
int b;
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
a = 10;
b = 10;
}
static void _I_Person_test(Person * self, SEL _cmd) {
(void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA);
}
可以看出，因為全局變量都在靜態數據區，在程序結束前不會被銷毀，所以block直接訪問了對應的變量，而沒有在Persontest_block_impl_0結構體中給變量預留位置。
捕獲對象的變量
代碼：
@interface Person()
{
int _a;
}
@end
@implementation Person
- (void)test
{
void (^block)() = ^{
_a;
};
}
@end
轉換后：
struct __Person__test_block_impl_0 {
...
Person *self;
__Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
Person *self = __cself->self; // bound by copy
(*(int *)((char *)self + OBJC_IVAR_$_Person$_a));
}
static void _I_Person_test(Person * self, SEL _cmd) {
void (*block)() = ((void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344));
}
可以看到，即使 block只是引用對象的變量，但是底層依然引用的是對象本身 self，這和直接使用 self.a產生的循環引用的問題是一樣的。所以，要在 block 內使用對象的弱引用，即可解決循環引用的問題。并且，對變量a的訪問也是通過 self的地址加 a的偏移量的形式。
捕獲__block修飾的基本變量
代碼：
__block int a;
^{
a = 10;
};
轉換后：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
struct __main_block_impl_0 {
...
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=0) : a(_a->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
...
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_a_0 *a = __cself->a; // bound by ref
(a->__forwarding->a) = 10;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);}
static struct __main_block_desc_0 {
...
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[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 1};
((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
}
return 0;
}
可以看到，被__block修飾的變量被封裝成了一個對象，類型為__Block_byref_a_0，然后把&a作為參數傳給了block。
__Block_byref_a_0 成員含義如下：
- __isa: 指向所屬類的指針，被初始化為
(void*)0 - __forwarding: 指向對象在堆中的拷貝
- __flags: 標志變量，在實現block的內部操作時會用到
- __size: 對象的內存大小
- a: 原始類型的變量
其中，isa、__flags 和 __size 的含義和之前類似，而 __forwarding 是用來指向對象在堆中的拷貝，runtime.c 里有源碼說明：
static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
...
struct Block_byref *copy = (struct Block_byref *)_Block_allocator(src->size, false, isWeak);
copy->flags = src->flags | _Byref_flag_initial_value; // non-GC one for caller, one for stack
// 堆中拷貝的forwarding指向它自己
copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
// 棧中的forwarding指向堆中的拷貝
src->forwarding = copy; // patch stack to point to heap copy
copy->size = src->size;
...
}
這樣做是為了保證在 block內 或 block 變量后面對變量a的訪問，都是直接訪問堆內的對象，而不上棧上的變量。同時，在 block 拷貝到堆內時，它所捕獲的由 __block 修飾的局部基本類型也會被拷貝到堆內（拷貝的是封裝后的對象），從而會有 copy 和 dispose處理函數。
Block_byref的結構定義在 Block_private.h 文件里有介紹:
struct Block_byref {
void *isa;
struct Block_byref *forwarding;
int flags; /* refcount; */
int size;
void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src);
void (*byref_destroy)(struct Block_byref *);
/* long shared[0]; */
};
// flags/_flags類型
enum {
/* See function implementation for a more complete description of these fields and combinations */
// 是一個對象
BLOCK_FIELD_IS_OBJECT = 3, /* id, NSObject, __attribute__((NSObject)), block, ... */
// 是一個block
BLOCK_FIELD_IS_BLOCK = 7, /* a block variable */
// 被__block修飾的變量
BLOCK_FIELD_IS_BYREF = 8, /* the on stack structure holding the __block variable */
// 被__weak修飾的變量，只能被輔助copy函數使用
BLOCK_FIELD_IS_WEAK = 16, /* declared __weak, only used in byref copy helpers */
// block輔助函數調用（告訴內部實現不要進行retain或者copy）
BLOCK_BYREF_CALLER = 128 /* called from __block (byref) copy/dispose support routines. */
};
可以看到，Block_byref 和 __Block_byref_a_0 的前4個成員類型相同，可以互相轉化。
** copy 函數
copy 的實現函數是 _Block_object_assign，它根據對象的 flags 來判斷是否需要拷貝，或者只是賦值，函數實現在 runtime.c 里：
// _Block_object_assign源碼
void _Block_object_assign(void *destAddr, const void *object, const int flags) {
...
else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF) {
// copying a __block reference from the stack Block to the heap
// flags will indicate if it holds a __weak reference and needs a special isa
_Block_byref_assign_copy(destAddr, object, flags);
}
...
}
// _Block_byref_assign_copy源碼
static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
// 這里因為前面4個成員的內存分布一樣，所以直接轉換后，使用Block_byref的成員變量名，能訪問到__Block_byref_a_0的前面4個成員
struct Block_byref **destp = (struct Block_byref **)dest;
struct Block_byref *src = (struct Block_byref *)arg;
...
else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
// 從main函數對__Block_byref_a_0的初始化，可以看到初始化時將flags賦值為0
// 這里表示第一次拷貝，會進行復制操作，并修改原來flags的值
// static int _Byref_flag_initial_value = BLOCK_NEEDS_FREE | 2;
// 可以看出，復制后，會并入BLOCK_NEEDS_FREE，后面的2是block的初始引用計數
...
copy->flags = src->flags | _Byref_flag_initial_value;
...
}
// 已經拷貝到堆了，只增加引用計數
else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {
latching_incr_int(&src->forwarding->flags);
}
// 普通的賦值，里面最底層就*destptr = value;這句表達式
_Block_assign(src->forwarding, (void **)destp);
}
主要操作都在代碼注釋中了，總體來說，__block修飾的基本類型會被包裝為對象，并且只在最初block拷貝時復制一次，后面的拷貝只會增加這個捕獲變量的引用計數。
** dispose 函數
dispose 的實現函數是 _Block_object_dispose，代碼依然可以在 runtime.c 里：
void _Block_object_dispose(const void *object, const int flags) {
//printf("_Block_object_dispose(%p, %x)\n", object, flags);
if (flags & BLOCK_FIELD_IS_BYREF) {
// get rid of the __block data structure held in a Block
_Block_byref_release(object);
}
...
}
// Old compiler SPI
static void _Block_byref_release(const void *arg) {
struct Block_byref *shared_struct = (struct Block_byref *)arg;
int refcount;
// dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
shared_struct = shared_struct->forwarding;
...
refcount = shared_struct->flags & BLOCK_REFCOUNT_MASK;
...
else if ((latching_decr_int(&shared_struct->flags) & BLOCK_REFCOUNT_MASK) == 0) {
...
}
}
可以看到，被__block修改的變量，釋放時要 latching_decr_int減引用計數，直到計數為0，就釋放改對象；而普通的對象、block，就直接釋放銷毀。
捕獲沒有__block修飾的對象
代碼：
NSObject *a = [[NSObject alloc] init];
Block block = ^ {
a;
};
轉換后部分結果如下：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSObject *a = __cself->a; // bound by copy
a;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 3/*BLOCK_FIELD_IS_OBJECT*/);}
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
...
Block block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, 570425344));
}
return 0;
}
對象在沒有__block修飾時，并沒有產生__Block_byref_a_0結構體，只是將標志位修改為BLOCK_FIELD_IS_OBJECT。而在_Block_object_assign中對應的判斷分支代碼如下:
...
else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
_Block_retain_object(object);
_Block_assign((void *)object, destAddr);
}
...
可以看到，block復制時，會retain捕捉對象，以增加其引用計數。
捕獲有__block修飾的對象
代碼：
__block NSObject *a = [[NSObject alloc] init];
Block block = ^ {
a;
};
轉化后部分結果如下：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
NSObject *a;
};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 33554432, sizeof(__Block_byref_a_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131,....};
Block block = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344);
}
// 以下的40表示__Block_byref_a_0對象a的位移（4個指針(32字節)＋2個int變量(8字節)＝40字節）
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
_Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void *src) {
_Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}
可以看到，對于對象，處理增加了__Block_byref_a_0外，還另外增加了兩個輔助函數__Block_byref_id_object_copy、__Block_byref_id_object_dispose,以實現對對象內存的管理。其中兩者的最后一個參數131表示BLOCK_BYREF_CALLER|BLOCK_FIELD_IS_OBJECT，BLOCK_BYREF_CALLER表示在內部實現中不對a對象進行retain或copy；以下為_Block_object_assign函數的部分代碼：
if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
...
else {
// do *not* retain or *copy* __block variables whatever they are
_Block_assign((void *)object, destAddr);
}
}
_Block_byref_assign_copy函數的以下代碼會對上面的輔助函數__Block_byref_id_object_copy_131進行調用；570425344表示BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR，即（1<<25 | 1<<29），_Block_byref_assign_copy函數的部分代碼:
if (src->flags & BLOCK_HAS_COPY_DISPOSE) {
// Trust copy helper to copy everything of interest
// If more than one field shows up in a byref block this is wrong XXX
copy->byref_keep = src->byref_keep;
copy->byref_destroy = src->byref_destroy;
(*src->byref_keep)(copy, src);
}
四、ARC中block的工作特點
在ARC模式下，在棧間傳遞block時，不需要手動copy棧中的block，即可讓block正常工作。主要原因是ARC對棧中的block自動執行了copy，將_NSConcreteStackBlock類型的block轉換成了_NSConcreteMallocBlock類型的block。
1. block，非函數參數
代碼：
int i = 10;
void (^block)() = ^{i;};
__unsafe_unretained void (^weakBlock)() = ^{i;};
void (^stackBlock)() = ^{};
NSLog(@"%@", ^{i;});
NSLog(@"%@", block);
NSLog(@"%@", weakBlock);
NSLog(@"%@", stackBlock);
/* ARC
<__NSStackBlock__: 0x7fff5fbff708>
<__NSMallocBlock__: 0x100300000>
<__NSStackBlock__: 0x7fff5fbff738>
<__NSGlobalBlock__: 0x100001110>
*/
/* MRC
<__NSStackBlock__: 0x7fff5fbff6e0>
<__NSStackBlock__: 0x7fff5fbff740>
<__NSStackBlock__: 0x7fff5fbff710>
<__NSGlobalBlock__: 0x1000010e0>*/
從打印結果可以看出，ARC模式下，block 只有引用了外部的變量，并且被強引用，才會被拷貝到堆上；只引用了外部的變量，或者被弱引用都只在棧上創建；如果沒有引用外部變量，無論是否被強引用，都會被轉換為全局 block，也就是說，在編譯時，這個block的所有內容已經在代碼段中生成了。
2. block，作為參數傳遞
代碼
typedef void (^Block)();
NSMutableArray *arrays;
void testBlock() {
int a = 5;
[arrays addObject:^{
NSLog(@"%d", a);
}];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here..
arrays = @[].mutableCopy;
testBlock();
Block block = [arrays firstObject];
NSLog(@"%@", block);
/* ARC
* <__NSMallocBlock__: 0x1006034c0>
*/
/* MRC
* 崩潰，野指針
*/
}
return 0;
}
可以看出，ARC模式下，棧區的block 被拷貝到了堆區，在 testBlock 函數結束后依然可以訪問；而 MRC模式下，由于我們沒有手動執行[block copy]來將block拷貝到堆區，隨著函數生命周期結束，block被銷毀，訪問時出現野指針錯誤，但是如果把testBlock函數中的block打印語句刪掉:
NSLog(@"%d", a);
那么，block就變為全局的，在MRC模式下，再次訪問不會出錯。
參考文章
http://www.lxweimin.com/p/51d04b7639f1
http://www.lxweimin.com/p/aff2cad778c0
http://www.galloway.me.uk/2013/05/a-look-inside-blocks-episode-3-block-copy/
runtime.c
Block.private.h
