iOS - Block底層解析

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.jianshu.com/p/51d04b7639f1

http://www.jianshu.com/p/aff2cad778c0

http://www.galloway.me.uk/2013/05/a-look-inside-blocks-episode-3-block-copy/

runtime.c

Block.private.h

iOS - Block底層解析

一、Block定義

1. Block 定義及使用

2. 項目中使用格式

二、Block底層實現

1. block內存結構

2. 創建block

3. 轉換結構

三、Block類型

1. 全局block 和棧block

2. 捕獲外部參數對棧區block結構的影響

四、ARC中block的工作特點

1. block，非函數參數

2. block，作爲參數傳遞

參考文章

iOS - Block底層解析

SVProgressHUD源碼解讀(2.0.3)

Monad詳解

ReactiveCocoa源碼解讀（二）

iOS 10 UserNotification框架解析 - 本地通知

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

iOS - Block底層解析

一、Block定義

1. Block 定義及使用

2. 項目中使用格式

二、Block底層實現

1. block內存結構

2. 創建block

3. 轉換結構

三、Block類型

1. 全局block 和 棧block

2. 捕獲外部參數對棧區block結構的影響

四、ARC中block的工作特點

1. block，非函數參數

2. block，作爲參數傳遞

參考文章

1. 全局block 和棧block