前言

在IOS開發(fā)中大家對(duì)block用的非常多，一般情況下僅僅停留在會(huì)用的層面，具體的block的底層是如何實(shí)現(xiàn)的是一概不知。也許很多人就問block會(huì)用不就行了，知道底層原理干什么。比如block是如何捕獲變量的，block底層是什么類型。如果你了解它的底層原理就不會(huì)有這些疑問。作為一名程序開發(fā)者，必須要弄清楚其底層原理。

準(zhǔn)備工作

• Objc-818.2
• libclosure-79

1. block底層分析

1.1 block捕獲普通變量（非__block修飾）

1.1.1 block捕獲對(duì)象類型

創(chuàng)建一個(gè)NSObject對(duì)象在block內(nèi)部使用。代碼如下

int main(int argc, char * argv[]) {
NSString * appDelegateClassName;
@autoreleasepool {
    NSObject * obj  = [NSObject alloc];
    void (^ block)(void) = ^{
        NSLog(@"----%@",obj);
    };
    block();
}
return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通過xcrun把main.m文件編譯成main.cpp文件，提取block相關(guān)的關(guān)鍵底層代碼如下：

main.cpp提取后代碼

• __block_impl數(shù)據(jù)結(jié)構(gòu)

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

__block_impl結(jié)構(gòu)體中的FuncPtr用來保存任務(wù)功能函數(shù)即__main_block_func_0函數(shù)的地址。

• __main_block_desc_0 數(shù)據(jù)結(jié)構(gòu)

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

__main_block_desc_0結(jié)構(gòu)中的變量copy和dispose是非常重要的函數(shù)保存著__main_block_copy_0和__main_block_dispose_0函數(shù)地址。在block進(jìn)行拷貝和釋放時(shí)調(diào)用。

• __main_block_impl_0構(gòu)造函數(shù)

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

構(gòu)造函數(shù)__main_block_impl_0對(duì)block結(jié)構(gòu)體中相關(guān)屬性進(jìn)行設(shè)置。構(gòu)造函數(shù)__main_block_impl_0的第一個(gè)參數(shù)為__main_block_func_0方法實(shí)現(xiàn)地址，在聲明定義block時(shí)，將block的任務(wù)函數(shù)封裝到FuncPtr屬性中。

func定位

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

1.1.2 block捕獲非對(duì)象類型

用int類型的變量進(jìn)行實(shí)例探究。代碼如下：

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        int a = 10;
        void (^ block)(void) = ^{
            NSLog(@"----%d",a);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通過xcrun把main.m文件編譯成main.cpp文件，提取block相關(guān)的關(guān)鍵底層代碼如下：

1.1.3 總結(jié)：main函數(shù)中和block操作相關(guān)的有兩個(gè)步驟

• 對(duì)block的結(jié)構(gòu)體進(jìn)行初始化賦值，參數(shù)有__main_block_func_0任務(wù)功能函數(shù)，&__main_block_desc_0_DATA描述信息的函數(shù)地址以及外界的變量obj。

  • block底層會(huì)被編譯成一個(gè)結(jié)構(gòu)體類型
  • block結(jié)構(gòu)體此時(shí)自動(dòng)生成了一個(gè)NSObject *__strong obj的變量，對(duì)結(jié)構(gòu)體進(jìn)行賦值時(shí)obj(_obj)通過C++方式給block結(jié)構(gòu)體的obj賦值
  • 將 __main_block_func_0賦值給block結(jié)構(gòu)體中的變量__block_impl中的FuncPtr保存
  • 將&__main_block_desc_0_DATA賦值給block結(jié)構(gòu)體中的變量__main_block_desc_0中的Desc保存

• 調(diào)用blcok結(jié)構(gòu)體中__block_impl變量中的FuncPtr變量執(zhí)行任務(wù)功能函數(shù)

  • FuncPtr執(zhí)行時(shí)會(huì)把blcok作為參數(shù)，因?yàn)橐@取blcok中的objc變量
  • __main_block_func_0方法中使用的變量其實(shí)就是獲取的blcok結(jié)構(gòu)體中新生成的obj。結(jié)構(gòu)體中的obj和外界變量的obj指向的同一片內(nèi)存空間

• blcok的賦值和執(zhí)行都是通過blcok內(nèi)部的數(shù)據(jù)或者函數(shù)去執(zhí)行，都是用blcok中保存的數(shù)據(jù)

1.1.4 問題補(bǔ)充

為什么普通的變量（不用__block修飾）在blcok內(nèi)部不能進(jìn)行修改？
因?yàn)?code>blcok內(nèi)部的變量obj和外界變量obj指向的是同一塊內(nèi)存，如果此時(shí)blcok內(nèi)部的變量obj重新指向一塊內(nèi)存即obj中地址發(fā)生改變，而此時(shí)外界的變量obj還是指向它開始指向的內(nèi)存空間沒有改變，此時(shí)編譯器不知道該用哪個(gè)obj造成代碼有歧義，所以不能進(jìn)行修改僅僅可讀。這也就大家常說的值拷貝。

1.2 block捕獲__block修飾的變量

1.2.1 block捕獲__block修飾的對(duì)象類型

給變量obj添加__block修飾，并且在block內(nèi)存進(jìn)行修改。代碼如下：

 int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        __block NSObject * obj  = [NSObject alloc];
        void (^ block)(void) = ^{
            obj = [NSObject alloc];
            NSLog(@"----%@",obj);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通過xcrun把main.m文件編譯成main.cpp文件，提取block相關(guān)的關(guān)鍵底層代碼如下：

main.cpp

編譯器會(huì)把__block修飾的變量底層編譯成一個(gè)結(jié)構(gòu)體__Block_byref_obj_0，結(jié)構(gòu)如下：

struct __Block_byref_obj_0 {
  void *__isa;
__Block_byref_obj_0 *__forwarding;//__Block_byref_obj_0的地址默認(rèn)賦值時(shí)指向自己
 int __flags;//標(biāo)識(shí)
 int __size;//大小
 void (*__Block_byref_id_object_copy)(void*, void*);//copy方法
 void (*__Block_byref_id_object_dispose)(void*);//dispose方法
 NSObject *__strong obj;//對(duì)象的地址
};

編譯器把__block修飾的變量底層編譯成結(jié)構(gòu)體時(shí)，會(huì)進(jìn)行初始化賦值，具體如下：

• (__Block_byref_obj_0 *)&obj賦值給 __forwarding，其實(shí)就是__forwarding指向__Block_byref_obj_0地址。簡(jiǎn)單的說__Block_byref_obj_0中的__forwarding指向__Block_byref_obj_0
• __Block_byref_id_object_copy_131賦值給__Block_byref_id_object_copy
• __Block_byref_id_object_dispose_131賦值給__Block_byref_id_object_dispose
• 對(duì)象的地址賦值給變量 NSObject *__strong obj

blcok的結(jié)構(gòu)體初始化賦值時(shí)，把變量的結(jié)構(gòu)體__Block_byref_obj_0 obj的地址作為參數(shù)

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

此時(shí)把_obj->__forwarding賦值 __main_block_impl_0結(jié)構(gòu)體中自動(dòng)生成的變量__Block_byref_obj_0 *obj，也就意味著obj也是指向__Block_byref_obj_0結(jié)構(gòu)體
(block)->FuncPtr(block)調(diào)用任務(wù)功能函數(shù)代碼如下:

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

  __Block_byref_obj_0 *obj = __cself->obj; // bound by ref
  
 (obj->__forwarding->obj) = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)
 ((id)objc_getClass("NSObject"), sel_registerName("alloc"));
 
 NSLog((NSString *)&__NSConstantStringImpl,(obj->__forwarding->obj)); 
}

• __Block_byref_obj_0 *obj = __cself- >obj把blcok結(jié)構(gòu)體中的obj賦值給obj，也就是把__Block_byref_obj_0的地址賦值給了__Block_byref_obj_0 *obj
• obj->__forwarding指向的是__Block_byref_obj_0結(jié)構(gòu)體的地址
• obj->__forwarding->obj就是__Block_byref_obj_0結(jié)構(gòu)體中的NSObject *__strong obj變量
• obj->__forwarding->obj修改obj時(shí)，block內(nèi)部和外部變量的指向沒有改變，只是改變了外部和內(nèi)部變量里面的obj，實(shí)際上訪問到的obj就是同一個(gè)，不管這個(gè)obj有沒有被修改。

1.2.2 block捕獲__block修飾的非對(duì)象類型

用__block修飾的int類型變量進(jìn)行實(shí)例探究。代碼如下：

 int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        __block int a = 10;
        void (^ block)(void) = ^{
            NSLog(@"----%d",a);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通過xcrun把main.m文件編譯成main.cpp文件，提取block相關(guān)的關(guān)鍵底層代碼如下：

main.cpp

1.2.3 總結(jié)__Block修飾的對(duì)象在block內(nèi)部做了什么

• __block修飾的變量底層會(huì)生成一個(gè)__Block_byref_obj_0結(jié)構(gòu)體
• __Block_byref_obj_0結(jié)構(gòu)體中保存著對(duì)象的地址以及__Block_byref_obj_0地址
• blcok內(nèi)部和外部的變量都是指向的__Block_byref_obj_0地址。而__Block_byref_obj_0中的變量obj發(fā)生改變時(shí)blcok內(nèi)部和外部的變量仍然指向__Block_byref_obj_0地址，然后獲取obj

1.3 __blcok修飾變量指示圖

根據(jù).cpp文件中變量的賦值和修改流程所畫的圖，更好的理解為什么__block修飾的變量可以修改。如下：

指示圖

1.4 block未捕獲變量（全局或靜態(tài)）

1.4.1 block未捕獲變量

 int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        
        void (^ block)(void) = ^{
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通過xcrun把main.m文件編譯成main.cpp文件，提取block相關(guān)的關(guān)鍵底層代碼如下：

main.cpp

1.4.2 block捕獲全局或靜態(tài)變量

static int  a  = 100;
int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        void (^ block)(void) = ^{
            NSLog(@"----%d",a);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

通過xcrun把main.m文件編譯成main.cpp文件，提取block相關(guān)的關(guān)鍵底層代碼如下：

main.cpp

2. block底層探究

通過對(duì)main.cpp文件分析，大致理清楚了blcok的變量賦值以及block的調(diào)用。但是棧區(qū)blcok變成堆區(qū)blcok過程還不了解。下面通過匯編跟蹤流程的方式進(jìn)行探究，請(qǐng)繼續(xù)往下走咯！

2.1 全局block的底層探究

運(yùn)行一個(gè)案例給blcok的設(shè)置斷點(diǎn)，如下圖所示：

查看斷點(diǎn)

匯編斷點(diǎn)

objc_retainBlock

• objc_retainBlock匯編中下一步會(huì)跳轉(zhuǎn)到_Block_copy
• objc_retainBlock方法是在libobjc.A.dylib源碼庫(kù)中
• 真機(jī)情況下x0表示方法的第一個(gè)參數(shù)即消息的接收者。通過lldb調(diào)試發(fā)現(xiàn)此時(shí)的消息接收者是block。而且此時(shí)的block是一個(gè)全局block

給_Block_copy添加符號(hào)斷點(diǎn)，繼續(xù)調(diào)試，如下：

_Block_copy

• _Block_copy方法在libsystem_blocks.dylib源碼庫(kù)中
• 通過lldb調(diào)試發(fā)現(xiàn)_Block_copy的消息接收者是block。此時(shí)的block仍然是一個(gè)全局block

_Block_copy匯編結(jié)束的位置會(huì)return一個(gè)返回值，在真機(jī)情況下，返回值會(huì)保存到x0寄存器中。那么查看返回值如下：

查看返回值類型

2.2 堆區(qū)block的底層探究

創(chuàng)建一個(gè)堆block，給blcok的設(shè)置斷點(diǎn)，如下圖所示：

斷點(diǎn)堆block

打開匯編斷點(diǎn)

_Block_copy

查看return的類型

• 棧區(qū)block經(jīng)過_Block_copy以后變成堆區(qū)block
• 棧區(qū)block和堆區(qū)block的地址不一樣說明是在堆區(qū)新開辟的內(nèi)存
• 堆區(qū)block里面的變量invoke、cpoy、disponse地址是一樣的，說明棧區(qū)block在運(yùn)行時(shí)會(huì)cpoy一份到堆區(qū)，形成一個(gè)新的堆區(qū)block然后返回

2.3 棧區(qū)block的底層探究

創(chuàng)建一個(gè)棧區(qū)的block案例，給棧區(qū)blcok設(shè)置斷點(diǎn)，如下圖所示：

棧block

打開匯編斷點(diǎn)

2.4 總結(jié)以上三種情況

• 全局block在運(yùn)行時(shí)調(diào)用_Block_copy方法后，仍然是全局block
• 堆區(qū)block是由編譯時(shí)的棧區(qū)block在運(yùn)行時(shí)調(diào)用_Block_copy方法，生成新的堆區(qū)block
• 棧區(qū)blcok不會(huì)進(jìn)行_Block_copy的操作

結(jié)論：如果block賦值給強(qiáng)引用或者copy修飾的變量，那么block會(huì)進(jìn)行_Block_copy操作，如果是賦值給__weak修飾的變量則不會(huì)進(jìn)行_Block_copy的操作

2.5 block的類型Block_layout結(jié)構(gòu)體

通過.cpp文件和匯編對(duì)block的類型有個(gè)初步了解，但是還是不全面而且不夠深入。同類型的blcok里面的變量也是有區(qū)別的， 只有通過底層源碼去探究block類型。objc_retainBlock方法是在libobjc.A.dylib源碼庫(kù)中，在objc4-818.2源碼中全局搜索objc_retainBlock，如下：

objc_retainBlock

_Block_copy

struct Block_layout {
    //block 的類型
    void * __ptrauth_objc_isa_pointer isa;  // 8 字節(jié)
    //用來標(biāo)識(shí)`blcok`的信息是按位存儲(chǔ)的，類似于對(duì)象中isa的`bits`
    volatile int32_t flags;// 4字節(jié)
    //保留字段
    int32_t reserved;// 4字節(jié)
    //函數(shù)指針，保存任務(wù)函數(shù)的實(shí)現(xiàn)地址 就是.cpp文件中的FuncPtr
    BlockInvokeFunction invoke; // 8字節(jié)
    //描述信息
    struct Block_descriptor_1 *descriptor;// 8字節(jié)
};

Block_layout結(jié)構(gòu)體變量的含義:

• isa：表示block的類型（棧、堆 、全局）
• flags：標(biāo)識(shí)符類似于對(duì)象中isa的bits
• reserved：保留字段
• invoke：函數(shù)指針，保存任務(wù)函數(shù)的實(shí)現(xiàn)地址 就是.cpp文件中的FuncPtr函數(shù)
• descriptor：描述信息

flag標(biāo)識(shí)

// Values for Block_layout->flags to describe block objects
enum {
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    BLOCK_INLINE_LAYOUT_STRING = (1 << 21), // compiler

#if BLOCK_SMALL_DESCRIPTOR_SUPPORTED
    BLOCK_SMALL_DESCRIPTOR =  (1 << 22), // compiler
#endif

    BLOCK_IS_NOESCAPE =       (1 << 23), // compiler
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    BLOCK_IS_GC =             (1 << 27), // runtime
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};

• 第1位 BLOCK_DEALLOCATING ： 釋放標(biāo)記，-般常用 BLOCK_NEEDS_FREE 做位與操作，一同傳入Flags，告知該block可釋放
• 低16位 BLOCK_REFCOUNT_MASK：存儲(chǔ)引用計(jì)數(shù)的值，是一個(gè)可選用參數(shù)
• 第22位BLOCK_SMALL_DESCRIPTOR:包含了Block_descriptor_1、Block_descriptor_2 和Block_descriptor_3
• 第24位 BLOCK_NEEDS_FREE：低16是否有效的標(biāo)志，程序根據(jù)它來決定是否增加或是減少引用計(jì)數(shù)位的值
• 第25位 BLOCK_HAS_COPY_DISPOSE：是否擁有拷貝輔助函數(shù)(a copy helper function)
• 第26位 BLOCK_HAS_CTOR：是否擁有block 析構(gòu)函數(shù)
• 第27位BLOCK_IS_GC：標(biāo)志是否有垃圾回收;//OS X
• 第28位 BLOCK_IS_GLOBAL：標(biāo)志是否是全局block
• 第30位 BLOCK_HAS_SIGNATURE：與BLOCK_USE_STRET相對(duì)，判斷當(dāng)前block是否擁有一個(gè)簽名。用于runtime時(shí)動(dòng)態(tài)調(diào)用

在這些標(biāo)記位中BLOCK_HAS_COPY_DISPOSE和BLOCK_HAS_SIGNATURE這兩個(gè)標(biāo)記位特別重要

• BLOCK_HAS_COPY_DISPOSE表示是否有Block_descriptor_2
• BLOCK_HAS_SIGNATURE表示是否有Block_descriptor_3
• 因?yàn)?code>Block_descriptor_1是必須要有的，所以沒有其標(biāo)記位
• 通過標(biāo)記位可以判斷Block_descriptor_1是必須有的，Block_descriptor_2和BLOCK_DESCRIPTOR_3是可選的

descriptor描述信息

• Block_descriptor_1

#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 {
    uintptr_t reserved;     //8字節(jié)
    uintptr_t size;         //8字節(jié)
};

• Block_descriptor_2

#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 {
    // requires BLOCK_HAS_COPY_DISPOSE
    BlockCopyFunction copy;          //8字節(jié)
    BlockDisposeFunction dispose;    //8字節(jié)
};

• Block_descriptor_3

#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 {
    // requires BLOCK_HAS_SIGNATURE
    const char *signature; //8字節(jié)
    const char *layout;    //8字節(jié)  // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};

• 對(duì)descriptor三種描述信息的總結(jié)
  • Block_descriptor_1是結(jié)構(gòu)體類型，其中reserved表示保留信息，size表示block大小
  • Block_descriptor_2是結(jié)構(gòu)體類型，其中copy存的是copy函數(shù)地址，dispose 存的是dispose函數(shù)地址
  • Block_descriptor_3是結(jié)構(gòu)體類型，其中signature表示簽名信息，layout表示block的擴(kuò)展布局

descriptor的構(gòu)造函數(shù)探究
下面探究下descriptor的構(gòu)造函數(shù)，究竟是如何獲取descriptor的。

• Block_descriptor_1

struct Block_descriptor_1 *desc1 = layout->descriptor;

• Block_descriptor_2

static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
{
    uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);
    desc += sizeof(struct Block_descriptor_1); //地址偏移獲取到descriptor_2
    return (struct Block_descriptor_2 *)desc;
}

• Block_descriptor_3

static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
    uint8_t *desc = (uint8_t *)_Block_get_descriptor(aBlock);//descriptor_1的地址
    desc += sizeof(struct Block_descriptor_1);//地址偏移descriptor_1的大小
    if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {//如果descriptor_2存在
        desc += sizeof(struct Block_descriptor_2);//繼續(xù)地址偏移descriptor_2大小
    }
    return (struct Block_descriptor_3 *)desc; //得到descriptor_3的地址
}

Block_descriptor_1是直接賦值，而Block_descriptor_2和Block_descriptor_3是通過地址偏移獲取的。在結(jié)合上面的標(biāo)志位再次驗(yàn)證Block_descriptor_1是必有的默認(rèn)的，Block_descriptor_2和Block_descriptor_3是可選的，根據(jù)標(biāo)記位判斷。

2.6 lldb驗(yàn)證Block_layout中變量

2.6.1 堆區(qū)block調(diào)試驗(yàn)證

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        NSObject * obj  = [NSObject alloc];
        void (^ block)(void) = ^{
            NSLog(@"----%@",obj);
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

在_Block_copy匯編開始的位置或者ret位置進(jìn)行調(diào)試，如下：

lldb調(diào)試

• flags的值是0x00000000c3000002，descriptor的值是0x0000000100390078
• 打印descriptor中存儲(chǔ)的信息得到size的值0x0000000000000028換算成10進(jìn)制等于40是Block_layout結(jié)構(gòu)體的大小。大家可能有疑問Block_layout結(jié)構(gòu)體的大小不是32，因?yàn)椴东@變量會(huì)在block內(nèi)部生成一個(gè)新的變量，現(xiàn)在捕獲的是一個(gè)指針類型(8字節(jié))所以Block_layout大小總共40個(gè)字節(jié)
• BLOCK_HAS_COPY_DISPOSE=(1 << 25)，flags & BLOCK_HAS_COPY_DISPOSE用來判斷是否有Block_descriptor_2
• BLOCK_HAS_SIGNATURE=(1 << 30)，flags & BLOCK_HAS_SIGNATURE用來判斷是否有Block_descriptor_3
• signature的值是0x000000010038ffa6，打印出的值是v8@?0

簽名信息的補(bǔ)充

驗(yàn)證簽名信息

2.6.2 全局block調(diào)試驗(yàn)證

int main(int argc, char * argv[]) {
    NSString * appDelegateClassName;
    @autoreleasepool {
        void (^ block)(void) = ^{
           
        };
        block();
    }
    return UIApplicationMain(argc, argv, nil, appDelegateClassName);
}

在_Block_copy匯編開始的位置或者ret位置進(jìn)行調(diào)試，如下：

lldb匯編調(diào)試

• Block_layout結(jié)構(gòu)體大小是0x0000000000000020轉(zhuǎn)換成10進(jìn)制32，因?yàn)闆]有捕獲變量所以大小只有32字節(jié)
• 全局block沒有Block_descriptor_2，有Block_descriptor_3
• 因?yàn)?code>內(nèi)存是連續(xù)的Block_descriptor_2沒有，那么0x0000000104a03f9b就是Block_descriptor_3的起始位置

2.7 blcok的三層拷貝

2.7.1 _Block_copy源碼探究

void *_Block_copy(const void *arg) {
    struct Block_layout *aBlock;

    if (!arg) return NULL;
    
    // The following would be better done as a switch statement
    aBlock = (struct Block_layout *)arg;
    //block是否需要釋放
    if (aBlock->flags & BLOCK_NEEDS_FREE) {
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    //如果是全局block就直接返回
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        return aBlock;
    }
    else {// 棧 - 堆 (編譯期)
          //編譯時(shí)期不能生成堆block 只能是棧block 只能進(jìn)行通過_Block_copy進(jìn)行開辟堆block
          // Its a stack block.  Make a copy.
        size_t size = Block_size(aBlock);
        struct Block_layout *result = (struct Block_layout *)malloc(size);
        if (!result) return NULL;
        //將aBlock拷貝到result中
        memmove(result, aBlock, size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;

#if __has_feature(ptrauth_signed_block_descriptors)
        //BLOCK_SMALL_DESCRIPTOR 是包含了Block_descriptor_1、Block_descriptor_2 和 Block_descriptor_3
        //根據(jù)flags的標(biāo)志位來判斷的
        if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
            //里面是descriptor的拷貝賦值
            uintptr_t oldDesc = ptrauth_blend_discriminator(
                    &aBlock->descriptor,
                    _Block_descriptor_ptrauth_discriminator);
            uintptr_t newDesc = ptrauth_blend_discriminator(
                    &result->descriptor,
                    _Block_descriptor_ptrauth_discriminator);

            result->descriptor =
                    ptrauth_auth_and_resign(aBlock->descriptor,
                                            ptrauth_key_asda, oldDesc,
                                            ptrauth_key_asda, newDesc);
        }
#endif
#endif
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        //result:是在堆區(qū)創(chuàng)建的block  aBlock:外面?zhèn)鬟M(jìn)來的棧的
        //調(diào)用Block_descriptor_2`copy`方法
        _Block_call_copy_helper(result, aBlock);
        // Set isa last so memory analysis tools see a fully-initialized object.
        //將isa設(shè)置位_NSConcreteMallocBlock即堆block
        result->isa = _NSConcreteMallocBlock;
        return result;
    }
}

源碼的流程如下：

• 如果block需要釋放，則直接釋放
• 如果block是全局block，則不需要操作直接返回
• 因?yàn)槎?code>block需要在堆區(qū)申請(qǐng)開辟內(nèi)存，編譯時(shí)并不會(huì)生成堆block，所以只能是棧block
• 通過malloc開辟新的內(nèi)存
• 通過memmove將棧區(qū)block數(shù)據(jù)拷貝到新開辟的內(nèi)存中
• 通過_Block_call_copy_helper調(diào)用Block_descriptor_2中的copy方法
• 將堆上block的isa設(shè)置為_NSConcreteMallocBlock

_Block_call_copy_helper源碼探究

 static void _Block_call_copy_helper(void *result, struct Block_layout *aBlock)
{   // 獲取`copy`函數(shù)的函數(shù)指針
    if (auto *pFn = _Block_get_copy_function(aBlock))
       // 調(diào)用copy方法
        pFn(result, aBlock);
}

• 通過_Block_get_copy_function方法獲取copy函數(shù)的函數(shù)指針
• 然后調(diào)用copy函數(shù)

_Block_get_copy_function方法探究

//獲取方法的指針
#define _Block_get_relative_function_pointer(field, type)      \
    ((type)((uintptr_t)(intptr_t)(field) + (uintptr_t)&(field)))
    
#define _Block_get_function_pointer(field)      \
    (field)

static inline __typeof__(void (*)(void *, const void *))
_Block_get_copy_function(struct Block_layout *aBlock)
{
    //如果沒有description_2,就沒有copy方法，直接返回NULL
    if (!(aBlock->flags & BLOCK_HAS_COPY_DISPOSE))
        return NULL;
    //獲取Block_descriptor_1的首地址
    void *desc = _Block_get_descriptor(aBlock);
#if BLOCK_SMALL_DESCRIPTOR_SUPPORTED
    //如果Block_descriptor_1，Block_descriptor_2，Block_descriptor_3 全都有
    if (aBlock->flags & BLOCK_SMALL_DESCRIPTOR) {
        struct Block_descriptor_small *bds =
                (struct Block_descriptor_small *)desc;
        //_Block_get_relative_function_pointer是一個(gè)宏
        return _Block_get_relative_function_pointer(
                bds->copy, void (*)(void *, const void *));
    }
#endif

    struct Block_descriptor_2 *bd2 =
            (struct Block_descriptor_2 *)((unsigned char *)desc +
                                          sizeof(struct Block_descriptor_1));
    //_Block_get_copy_fn 獲取copy的函數(shù)指針
    return _Block_get_copy_fn(bd2);
}

• 判斷是否有Block_descriptor_2，如果沒有返回NULL
• 如果有Block_descriptor_2，根據(jù)不同的情況下去獲取copy函數(shù)的函數(shù)指針

** 結(jié)論：_Block_call_copy_helper方法的作用就是獲取copy函數(shù)指針，調(diào)用copy函數(shù)**
** 注意：此時(shí)的copy函數(shù)是Block_descriptor_2中的copy函數(shù)**

2.7.2 _Block_object_assign源碼探究

main.cpp文件中block結(jié)構(gòu)體初始化時(shí)，結(jié)構(gòu)體中的descriptor是通過外面?zhèn)鬟M(jìn)來參數(shù)進(jìn)行賦值的，如下所示：

main.cpp

static void __main_block_copy_0(struct __main_block_impl_0*dst,
struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->obj, (void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);
}

• __main_block_copy_0函數(shù)中有兩個(gè)參數(shù)dst和src，dst是堆區(qū)block，src是棧區(qū)block
• 在探究_Block_copy方法時(shí)_Block_call_copy_helper(result, aBlock)方法中調(diào)用了copy方法，result是堆區(qū)block，aBlock是棧區(qū)block
• __main_block_copy_0函數(shù)中調(diào)用了_Block_object_assign方法。
• _Block_object_assign有三個(gè)參數(shù)，前兩個(gè)參數(shù)是block捕獲的變量，第三個(gè)參數(shù)捕獲變量的類型

捕獲變量的類型是枚舉的，如下：

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_FIELD_IS_BLOCK    =  7,  // a block variable
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

常用的類型

• BLOCK_FIELD_IS_OBJECT，變量類型是普通對(duì)象
• BLOCK_FIELD_IS_BLOCK，變量類型是block類型
• BLOCK_FIELD_IS_BYREF，變量類型是__block修飾變量

在libclosure-79源碼中全局搜索_Block_object_assign，找到其源碼如下：

 void _Block_object_assign(void *destArg, const void *object, const int flags) {
    const void **dest = (const void **)destArg;
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
      case BLOCK_FIELD_IS_OBJECT:
        // _Block_retain_object_default = fn (arc)
        _Block_retain_object(object);
        *dest = object;
        break;

      case BLOCK_FIELD_IS_BLOCK:
        *dest = _Block_copy(object);
        break;
    
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
        *dest = _Block_byref_copy(object);
        break;
        
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK: 
        *dest = object;
        break;

      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
        *dest = object;
        break;

      default:
        break;
    }
}

• 如果變量類型是普通對(duì)象，交給系統(tǒng)處理，此時(shí)進(jìn)行指針拷貝*dest = object，引用計(jì)數(shù)+1
• 如果變量類型是block類型，進(jìn)行_Block_copy操作
• 如果變量類型是__block修飾變量，進(jìn)行_Block_byref_copy操作

2.7.3 _Block_byref_copy源碼探究

** Block_byref結(jié)構(gòu)體探究**
_Block_byref_copy主要是對(duì)變量拷貝，_block修飾的變量底層編譯成Block_byref類型，其結(jié)構(gòu)如下：

/ Values for Block_byref->flags to describe __block variables
enum {
    // Byref refcount must use the same bits as Block_layout's refcount.
    // BLOCK_DEALLOCATING =      (0x0001),  // runtime
    // BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime

    BLOCK_BYREF_LAYOUT_MASK =       (0xf << 28), // compiler
    BLOCK_BYREF_LAYOUT_EXTENDED =   (  1 << 28), // compiler
    BLOCK_BYREF_LAYOUT_NON_OBJECT = (  2 << 28), // compiler
    BLOCK_BYREF_LAYOUT_STRONG =     (  3 << 28), // compiler
    BLOCK_BYREF_LAYOUT_WEAK =       (  4 << 28), // compiler
    BLOCK_BYREF_LAYOUT_UNRETAINED = (  5 << 28), // compiler

    BLOCK_BYREF_IS_GC =             (  1 << 27), // runtime

    BLOCK_BYREF_HAS_COPY_DISPOSE =  (  1 << 25), // compiler
    BLOCK_BYREF_NEEDS_FREE =        (  1 << 24), // runtime
};

// __block  -> {}

// 結(jié)構(gòu)體
struct Block_byref {
    void * __ptrauth_objc_isa_pointer isa; // 8
    struct Block_byref *forwarding;  // 8
    volatile int32_t flags; // contains ref count//4
    uint32_t size; // 4
};

struct Block_byref_2 {
    // requires BLOCK_BYREF_HAS_COPY_DISPOSE
    BlockByrefKeepFunction byref_keep; //= __Block_byref_id_object_copy_131
    BlockByrefDestroyFunction byref_destroy; // = __Block_byref_id_object_dispose_131
};

struct Block_byref_3 {
    // requires BLOCK_BYREF_LAYOUT_EXTENDED
    const char *layout;
};

• __block修飾的變量底層被編譯成了Block_byref結(jié)構(gòu)體類型
• Block_byref的類型和Block_layout的descriptor比較類似，都是通過flags來判斷Block_byref_2和Block_byref_3是否存在。既Block_byref_2和Block_byref_3是可選的。

_Block_byref_copy方法探究

static struct Block_byref *_Block_byref_copy(const void *arg) {
    struct Block_byref *src = (struct Block_byref *)arg;

    // __block 內(nèi)存是一樣 同一個(gè)家伙
    //
    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack
        // 在堆區(qū)開辟內(nèi)存將外界變量拷貝一份到堆區(qū)
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
        copy->isa = NULL;
        // byref value 4 is logical refcount of 2: one for caller, one for stack
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
        // 堆區(qū)中新開辟的copy和 外界變量src的forwarding指向同一片內(nèi)存
        // 也就意味著它們持有著同一個(gè)對(duì)象
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //這里和_Block_copy比較類似
        if (src->flags & BLOCK_BYREF_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
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
            copy2->byref_keep = src2->byref_keep;
            copy2->byref_destroy = src2->byref_destroy;

            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
                copy3->layout = src3->layout;
            }

            // 捕獲到了外界的變量 - 內(nèi)存處理 - 生命周期的保存
            //調(diào)用 Block_byref_2 中的byref_keep方法
            (*src2->byref_keep)(copy, src);
        }
        else {
            // Bitwise copy.
            // This copy includes Block_byref_3, if any.
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    // already copied to heap
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    
    return src->forwarding;
}

• 通過malloc方法開辟內(nèi)存將外界變量拷貝一份，存放到堆區(qū)新開辟的內(nèi)存中
• copy->forwarding = copy 和 src->forwarding = copy表明它們的forwarding指向同一片內(nèi)存，那么它們就持有同一個(gè)對(duì)象
• (*src2->byref_keep)(copy, src)調(diào)用Block_byref_2中的byref_keep方法

總結(jié)：_Block_byref_copy對(duì)__block修飾的變量進(jìn)行拷貝即對(duì)Block_byref進(jìn)行拷貝

2.7.4 byref_keep 源碼探究

byref_keep方法在結(jié)構(gòu)體Block_byref_2在底層編譯時(shí)已經(jīng)被初始化賦值了。查看main.cpp文件，如下：

main.cpp

結(jié)構(gòu)體大小統(tǒng)計(jì)

2.7.5 總結(jié)

• 通過_Block_copy方法，將棧區(qū)blcok拷貝一份放在堆區(qū)
• __block修飾的對(duì)象，通過_Block_byref_copy方法，將Block_byref結(jié)構(gòu)體類型進(jìn)行拷貝
• 通過_Block_object_assign方法，對(duì)Block_byref中的對(duì)象處理。實(shí)際上這一層沒有進(jìn)行拷貝，但是走的還是拷貝的流程

2.8 _Block_object_dispose探究

_Block_object_dispose方法和_Block_object_assign方法是對(duì)應(yīng)的，那么我們還是先從匯編入手，如下所示：

打開匯編斷點(diǎn)

void _Block_object_dispose(const void *object, const int flags) {
    switch (os_assumes(flags & BLOCK_ALL_COPY_DISPOSE_FLAGS)) {
      case BLOCK_FIELD_IS_BYREF | BLOCK_FIELD_IS_WEAK:
      case BLOCK_FIELD_IS_BYREF:
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_BLOCK:
        _Block_release(object);
        break;
      case BLOCK_FIELD_IS_OBJECT:
        _Block_release_object(object);
        break;
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT | BLOCK_FIELD_IS_WEAK:
      case BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK  | BLOCK_FIELD_IS_WEAK:
        break;
      default:
        break;
    }
}

_Block_object_dispose方法就是調(diào)用了block結(jié)構(gòu)體中Block_descriptor_2中的disponse，根據(jù)捕獲的變量類型_Block_object_dispose進(jìn)行不同的釋放操作。如果是__block修飾的變量會(huì)調(diào)用_Block_byref_release方法

_Block_byref_release方法探究

static void _Block_byref_release(const void *arg) {
    struct Block_byref *byref = (struct Block_byref *)arg;
    
    byref = byref->forwarding;
    
    if (byref->flags & BLOCK_BYREF_NEEDS_FREE) {
        int32_t refcount = byref->flags & BLOCK_REFCOUNT_MASK;
        os_assert(refcount);
        if (latching_decr_int_should_deallocate(&byref->flags)) {
            if (byref->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
                struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1);
                //byref_destroy 釋放銷毀變量 和 byref_keep對(duì)應(yīng)
                (*byref2->byref_destroy)(byref);
            }
            //釋放
            free(byref);
        }
    }
}

_Block_byref_release方法就是對(duì)象，變量的釋放和銷毀

3. 總結(jié)

block的底層探索過程非常的繞，需要滿滿的去理清內(nèi)部的關(guān)系。