iOS 底層探索： 學(xué)習(xí)大綱 OC篇

前言

• 關(guān)于Block我們用的已經(jīng)非常多了，其實Block完整稱為Block代碼塊，是一個獨立的代碼片段，存在于另一個編程結(jié)構(gòu)的范圍內(nèi), block 是 C 語言的擴充功能，我們可以認為它是 帶有自動變量的匿名函數(shù)，同時也是一個對象。為了進一步了解block，這篇開始探究Block的底層原理。
• 可編譯的libclosure-74源碼下載

目錄

• 1.block的基礎(chǔ)
• 2.block的內(nèi)存分配
• 3.block的循環(huán)引用
• 4.block的本質(zhì)
• 5.block的源碼解讀

一、block的基礎(chǔ)

** block創(chuàng)建的規(guī)則和使用的方法**

block定義分為兩個模塊。

• block變量（block：block代碼塊定義的聲明的變量名）
• 表達式（block：獨立的代碼片）

1. block 變量

block塊變量的定義和使用函數(shù)指針引用C函數(shù)的方式相同，您可以聲明一個變量來跟蹤塊，如下所示：

void (^simpleBlock)(void);
返回值類型 (^變量名)(參數(shù)列表)

2. block 表達式

block塊 表達式和C匿名函數(shù)的方法表達式相同。

^ int (int count) {
return count + 1;
};
^ 返回值類型 (參數(shù)列表) {表達式}

3. block塊使用

如下聲明了一個變量名為HJBlock的Block：

int (^ HJBlock)(int) = ^(int count) {
        return count + 1;
    };

當(dāng)Block類型變量作為屬性時 ： 延長block的使用時間使用copy修飾

typedef int (^ HJBlock)(int);
@property(copy) HJBlock blk;

-(void)initBlockProperty{
      _ blk = ^(int count) {
        return count + 1;
    };
}
-(void)action{
    _ blk();
}

當(dāng)Block類型變量作為函數(shù)的參數(shù)時

- (void)func:(int (^)(int))blk {
    NSLog(@"Param:%@", blk);
}
或者
typedef int (^ HJBlock)(int);

- (void)func:(HJBlock)blk {
    NSLog(@"Param:%@", blk);
}

Block類型變量作返回值時

- (int (^)(int))funcR {
    return ^(int count) {
        return count ++;
    };
}
或者
typedef int (^ HJBlock)(int);

- (HJBlock)funcR {
    return ^(int count) {
        return count ++;
    };
}

二 、block的內(nèi)存分配

NSGlobalBlock 全局類型block，存儲在內(nèi)存中的全局區(qū)，這種情況下block，無傳入?yún)?shù)無返回值。

void(^block)(void) = ^{
    NSLog(@"hello,block");
};
NSLog(@"%@", block);

<__NSGlobalBlock__: 0x1065fa088>
不訪問棧區(qū)的變量（如局部變量），且不訪問堆區(qū)的變量（如用alloc創(chuàng)建的對象）時，此時block存放在代碼區(qū)

NSMallocBlock 堆區(qū)類型block，存儲在內(nèi)存中的堆區(qū)，這種情況下block會訪問外部變量a，對a進行值copy。

int a = 10;
void(^block)(void) = ^{
    NSLog(@"block - %d", a);
};
NSLog(@"%@", block);

<__NSMallocBlock__: 0x600003305680>

NSStackBlock 棧區(qū)類型block，存儲在內(nèi)存中的棧區(qū)，這種情況打印的是未賦值給block對象的一種形態(tài)，一旦完成賦值，對a進行拷貝持有，就會變?yōu)闂^(qū)block。

 int a = 10;
void(^block)(void) = ^{
    NSLog(@"block - %d", a);
};
NSLog(@"%@", ^{
    NSLog(@"block - %d", a);
});

<__NSStackBlock__: 0x7ffeec33f518>

這種 block，在 MRC 中，是 StackBlock 。在 ARC 中，因為編譯器做了優(yōu)化，自動進行了 copy ，這種就是 MallocBlock 了。

優(yōu)化的原因：

• 如果 StackBlock 訪問了一個自動變量，因為自己是存在棧上的，所以變量也就會被保存在棧上。但是因為棧上的數(shù)據(jù)是由系統(tǒng)自動進行管理的，隨時都有可能被回收，非常容易造成野指針的問題。

• ARC 機制會自動將棧上的 block 復(fù)制到堆上，所以，ARC 下的 block 的屬性關(guān)鍵詞其實使用 strong 和 copy 都不會有問題，習(xí)慣使用 copy 吧。

• ARC 環(huán)境下，一旦 block 賦值就會觸發(fā) copy，block 就會 copy 到堆上，block也就會變成 __NSMallocBlock 。
• 當(dāng)然，如果刻意的去寫（沒有實際用處），ARC 環(huán)境下也是存在 __NSStackBlock 的，這種情況下，block 就在棧上。

總結(jié)

三、block的循環(huán)引用

block循環(huán)引用的案列：

NSString *name = @"hj";
self.block = ^(void){
    NSLog(@"%@",self.name);
};
self.block();

因為在block內(nèi)部使用了外部變量name，導(dǎo)致block持有了self，而self原本是持有block的，所以導(dǎo)致了self和block的相互持有,所以造成了循環(huán)引用。

解決方案1：ARC下 weak-stong-dance

如果block內(nèi)部并未嵌套block，直接使用__weak修飾self即可

typedef void(^ HJBlock)(void);

@property(nonatomic, copy) HJBlock SBlock;

__weak typeof(self) weakSelf = self;
self.SBlock = ^(void){
     NSLog(@"%@",weakSelf.name);
}

如果block內(nèi)部嵌套block，需要同時使用__weak 和 __strong

__weak typeof(self) weakSelf = self;
self. SBlock = ^(void){
    __strong typeof(weakSelf) strongSelf = weakSelf;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",strongSelf.name);
    });
};
self.SBlock();

• 其中strongSelf是一個臨時變量，在SBlock的作用域內(nèi)，即內(nèi)部block執(zhí)行完就釋放strongSelf
  這種方式屬于打破self對block的強引用，依賴于中介者模式，屬于自動置為nil，即自動釋放

解決方案2 ： __block修飾變量

__block ViewController *vc = self;
self.SBlock = ^(void){
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",vc.name);
        vc = nil;//手動釋放
    });
};
self.SBlock();

• 這種方式同樣依賴于中介者模式，屬于手動釋放，是通過__block修飾對象，主要是因為__block修飾的對象是可以改變的

【注意點 ：】這里的block必須調(diào)用，如果不調(diào)用block，vc就不會置空，那么依舊是循環(huán)引用，self和block都不會被釋放

解決方案3：將self作為參數(shù)

typedef void(^ HJBlock)(ViewController *);

@property(nonatomic, copy) HJBlock SBlock;

self. SBlock = ^(ViewController *vc){
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",vc.name);
    });
};
self. SBlock(self);

• 將對象self作為參數(shù)，提供給block內(nèi)部使用，不會有引用計數(shù)問題

四、block的本質(zhì)

舉例分析：

int main() {
    int count = 100;
    void (^ blk)() = ^(){
        NSLog(@"In Block:%d", count);
    };
    blk();
}

通過使用Clang把Block解析成C++源碼

xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc block.c

int main() {
    int count = 100;
    void (* blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, count));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
}

從解析出來的源代碼看，main內(nèi)包含一個__main_block_impl_0的Block塊，而定義的Block塊被解析成__block_impl，接下來看一下這些內(nèi)容Block塊的具體內(nèi)容。

// main_block 塊
struct __main_block_impl_0 {
  struct __block_impl impl;   //定義的那個block塊
  struct __main_block_desc_0* Desc;   // main Block的描述
  int count;                          //定義的那個count

//  block 實現(xiàn)內(nèi)部實現(xiàn)細節(jié)賦值等內(nèi)容
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _count, int flags=0) : count(_count) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};


// 主要是block塊對count進行復(fù)制出來
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int count = __cself->count; // bound by copy
                                             // __cself相當(dāng)于Objective-C中的self
        NSLog((NSString *)&__NSConstantStringImpl__var_folders_d0_ts4pl5295tnfzz5ls4lj_z8w0000gp_T_main2_e76fdd_mi_0, count);
}

// block塊的描述 
static struct __main_block_desc_0 {
  size_t reserved;   // block塊預(yù)留的內(nèi)存
  size_t Block_size;   // block塊的內(nèi)存
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

// Block塊的結(jié)構(gòu)體
struct __block_impl {   
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};

• 在Objective-C中，任何類的定義都是對象。類和類的實例（對象）沒有任何本質(zhì)上的區(qū)別。任何對象都有isa指針。block塊中包含isa，驗證蘋果文檔說Block是Object-C的對象。

• block的本質(zhì)是對象、函數(shù)、結(jié)構(gòu)體，由于block函數(shù)沒有名稱，也被稱為匿名函數(shù)

1、block為什么需要被調(diào)用

在底層block的類型__main_block_impl_0結(jié)構(gòu)體，通過其同名構(gòu)造函數(shù)創(chuàng)建，第一個傳入的block的內(nèi)部實現(xiàn)代碼塊，即__main_block_func_0，用fp表示，然后賦值給impl的FuncPtr屬性，然后在main中進行了調(diào)用，這也是block為什么需要調(diào)用的原因。如果不調(diào)用，block內(nèi)部實現(xiàn)的代碼塊將無法執(zhí)行，可以總結(jié)為以下兩點

• 函數(shù)聲明：即block內(nèi)部實現(xiàn)聲明成了一個函數(shù)__main_block_func_0

• 執(zhí)行具體的函數(shù)實現(xiàn)：通過調(diào)用block的FuncPtr指針，調(diào)用block執(zhí)行

2、block是如何獲取外界變量的

定義一個變量，并在block中調(diào)用

int main(){
    int a = 11;
    void(^block)(void) = ^{
        printf(" TEST- %d", a);
    };
    
     block();
}

編譯后：

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;//編譯時就自動生成了相應(yīng)的變量
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
    impl.isa = &_NSConcreteStackBlock;//block的isa默認是stackBlock
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int a = __cself->a; // bound by copy 值拷貝，即 a = 10，此時的a與傳入的__cself的a并不是同一個

        printf("TEST - %d", a);
}
    
int main(){

    int a = 11;
    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a));

     block)->FuncPtr(block);
}

• __main_block_func_0中的a是值拷貝，如果此時在block內(nèi)部實現(xiàn)中作 a++操作，是有問題的，會造成編譯器的代碼歧義，即此時的a是只讀的

【總結(jié)】：block捕獲外界變量時，在內(nèi)部會自動生成同一個屬性來保存

3、__block的原理

對a加一個__block，然后在block中對a進行++操作

int main(){

    __block int a = 11;
    void(^block)(void) = ^{
        a++;
        printf("TEST - %d", a);
    };
    
     block();
    return 0;
}

底層編譯為如下

struct __Block_byref_a_0 {//__block修飾的外界變量的結(jié)構(gòu)體
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

struct __main_block_impl_0 {//block的結(jié)構(gòu)體類型
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __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) {//構(gòu)造方法
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {//block內(nèi)部實現(xiàn)
  __Block_byref_a_0 *a = __cself->a; // bound by ref 指針拷貝，此時的對象a 與 __cself對象的a 指向同一片地址空間
        //等同于 外界的 a++
        (a->__forwarding->a)++;
        printf("TEST  - %d", (a->__forwarding->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, 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*/);}

int main(){
    //__Block_byref_a_0 是結(jié)構(gòu)體，a 等于 結(jié)構(gòu)體的賦值，即將外界變量a 封裝成對象
    //&a 是外界變量a的地址
    __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0), 11};
    //__main_block_impl_0中的第三個參數(shù)&a，是封裝的對象a的地址
    void(*block)(void) = __main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));

     ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
    return 0;
}

分析：

• main中的a是通過外界變量封裝的對象

• __main_block_impl_0中，將對象a的地址&a給構(gòu)造函數(shù)

• 在__main_block_func_0內(nèi)部對a的處理是指針拷貝，此時創(chuàng)建的對象a與傳入對象的a指向同一片內(nèi)存空間

總結(jié)：

• 外界變量會生成__Block_byref_a_0結(jié)構(gòu)體

• 結(jié)構(gòu)體用來保存原始變量的指針和值

• 將變量生成的結(jié)構(gòu)體對象的指針地址 傳遞給block，然后在block內(nèi)部就可以對外界變量進行操作了

對比

• 值拷貝 - 深拷貝，只是拷貝數(shù)值，且拷貝的值不可更改，指向不同的內(nèi)存空間，案例中普通變量a就是值拷貝

• 指針拷貝 - 淺拷貝，生成的對象指向同一片內(nèi)存空間，案例中經(jīng)過__block修飾的變量a就是指針拷貝

五、block的源碼解讀

源碼的追蹤

新建一個項目然后開啟匯編調(diào)試：注意盡量要在新建的項目里，舊項目有緩存，我驗證了多次，清除緩存也沒用。編譯器進行優(yōu)化，省略的一些符號。所以最好要在新建的項目中調(diào)試。

block的真正類型

可以到蘋果開源網(wǎng)站下載最新的libclosure-74源碼,通過查看_Block_copy的源碼實現(xiàn)，發(fā)現(xiàn)block在底層的真正類型是Block_layout，查看源碼如下：

// 注釋:Block 結(jié)構(gòu)體
struct Block_layout {
    //指向表明block類型的類
    void *isa;//8字節(jié) 指向表明block類型的類
    //用來作標(biāo)識符的，類似于isa中的位域,按bit位表示一些block的附加信息
    volatile int32_t flags; // contains ref count 4字節(jié)
    //保留信息，可以理解預(yù)留位置，用于存儲block內(nèi)部變量信息
    int32_t reserved;//4字節(jié)
    //函數(shù)指針，指向具體的block實現(xiàn)的調(diào)用地址
    BlockInvokeFunction invoke; 
    //block的附加信息, 比如保留變量數(shù)、block的大小、進行copy或dispose的輔助函數(shù)指針
    struct Block_descriptor_1 *descriptor;
    // imported variables
};

注：

• flags：標(biāo)識符，按bit位表示一些block的附加信息，類似于isa中的位域，其中flags的種類有以下幾種

// 注釋: flags 標(biāo)識
// Values for Block_layout->flags to describe block objects
enum {
    //釋放標(biāo)記，一般常用于BLOCK_BYREF_NEEDS_FREE做位與運算，一同傳入flags，告知該block可釋放
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    //存儲引用引用計數(shù)的 值，是一個可選用參數(shù)
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    //低16位是否有效的標(biāo)志，程序根據(jù)它來決定是否增加或者減少引用計數(shù)位的值
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    //是否擁有拷貝輔助函數(shù)，（a copy helper function）決定block_description_2
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    //是否擁有block C++析構(gòu)函數(shù)
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    //標(biāo)志是否有垃圾回收，OSX
    BLOCK_IS_GC =             (1 << 27), // runtime
    //標(biāo)志是否是全局block
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    //與BLOCK_HAS_SIGNATURE相對，判斷是否當(dāng)前block擁有一個簽名，用于runtime時動態(tài)調(diào)用
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    //是否有簽名
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    //使用有拓展，決定block_description_3
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};

• descriptor：block的附加信息分三類 ：Block_descriptor_1是必選的Block_descriptor_2 和 Block_descriptor_3都是可選的

//一定有，包含了保留信息和保留位的大小
#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 { 
    uintptr_t reserved;//保留信息
    uintptr_t size;//block大小
};

//不一定有，看flag中的BLOCK_HAS_COPY_DISPOSE，包含了block可以進行copy和dispose的函數(shù)指針。
#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 { 
    // requires BLOCK_HAS_COPY_DISPOSE
    BlockCopyFunction copy;//拷貝函數(shù)指針
    BlockDisposeFunction dispose;
};

//不一定有，看的flag中BLOCK_HAS_SIGNATURE和BLOCK_HAS_EXTENDED_LAYOUT，包含了簽名。
#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 { 
    // requires BLOCK_HAS_SIGNATURE
    const char *signature;//簽名
    const char *layout;     // contents depend on BLOCK_HAS_EXTENDED_LAYOUT 布局
};

關(guān)于descriptor的可以從其構(gòu)造函數(shù)中體現(xiàn)，其中Block_descriptor_2和Block_descriptor_3 都是通過 Block_descriptor_1的地址，經(jīng)過內(nèi)存平移得到的

static struct Block_descriptor_1 * _Block_descriptor_1(struct Block_layout *aBlock)
{
    return aBlock->descriptor;//默認打印
}
#endif

// 注釋:Block 的描述 : copy 和 dispose 函數(shù)
static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
{
    if (! (aBlock->flags & BLOCK_HAS_COPY_DISPOSE)) return NULL;
    uint8_t *desc = (uint8_t *)aBlock->descriptor;//descriptor_1的地址
    desc += sizeof(struct Block_descriptor_1);//通過內(nèi)存平移獲取
    return (struct Block_descriptor_2 *)desc;
}

// 注釋: Block 的描述 : 簽名相關(guān)
static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
    if (! (aBlock->flags & BLOCK_HAS_SIGNATURE)) return NULL;
    uint8_t *desc = (uint8_t *)aBlock->descriptor;
    desc += sizeof(struct Block_descriptor_1);
    if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {
        desc += sizeof(struct Block_descriptor_2);
    }
    return (struct Block_descriptor_3 *)desc;
}

block簽名

分析

• block在底層本質(zhì)是Block_layout，其參數(shù)中isa占8字節(jié)，flags占4字節(jié)，reserved占4字節(jié)，invoke占8字節(jié)，descriptor占8字節(jié)，所以我們讀取的第一個4段內(nèi)存中的第4個就是descriptor的地址；
• Block_descriptor_3的地址是由Block_descriptor_1偏移進行讀取的，根據(jù)_Block_descriptor_3函數(shù)中的代碼，我們的Block是否需要銷毀通過BLOCK_HAS_COPY_DISPOSE進行判斷，在讀取的第一個四段內(nèi)存中的第二段0x0000000000000020與上flags中的BLOCK_HAS_COPY_DISPOSE也就是1 << 25結(jié)果為0，所以只需要偏移Block_descriptor_1這個結(jié)構(gòu)體的內(nèi)存大??；
• Block_descriptor_1有兩個屬性，分別都是uintptr_t類型，uintptr_t實際就是long占8字節(jié)，兩個就是16字節(jié)，所以第二個四段內(nèi)存中的第三個就是Block_descriptor_3的首地址，也就是signature簽名信息的地址，是個char *類型，占8字節(jié)。打印結(jié)果為v8@?0，所以這就是我們當(dāng)前Block的簽名。

簽名信息分析：

打印簽名po [NSMethodSignature signatureWithObjCTypes:"v8@?0"]

//無返回值
return value: -------- -------- -------- --------
    type encoding (v) 'v'
    flags {}
    modifiers {}
    frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
    memory {offset = 0, size = 0}
argument 0: -------- -------- -------- --------
    //encoding = (@),類型是 @?
    type encoding (@) '@?'
    //@是isObject ，？是isBlock，代表 isBlockObject
    flags {isObject, isBlock}
    modifiers {}
    frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
    //所在偏移位置是8字節(jié)
    memory {offset = 0, size = 8}

結(jié)論：

• block的簽名為@?
• block的簽名信息類似于方法的簽名信息，主要是體現(xiàn)block的返回值，參數(shù)以及類型等信息

block的三層copy(一)

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// 重點提示: 這里是核心重點 block的拷貝操作: 棧Block -> 堆Block
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;//強轉(zhuǎn)為Block_layout類型對象，防止對外界造成影響
    if (aBlock->flags & BLOCK_NEEDS_FREE) {//是否需要釋放
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {//如果是全局block，直接返回
        return aBlock;
    }
    else {//為棧block 或者 堆block，由于堆區(qū)需要申請內(nèi)存，所以只可能是棧區(qū)
        // Its a stack block.  Make a copy. 它是一個堆棧塊block，拷貝。
        struct Block_layout *result =
            (struct Block_layout *)malloc(aBlock->descriptor->size);//申請空間并接收
        if (!result) return NULL;
        //通過memmove內(nèi)存拷貝，將 aBlock 拷貝至result
        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;//可以直接調(diào)起invoke
#endif
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed 告知可釋放
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        _Block_call_copy_helper(result, aBlock);
        // Set isa last so memory analysis tools see a fully-initialized object.
        result->isa = _NSConcreteMallocBlock;//設(shè)置block對象類型為堆區(qū)block
        return result;
    }
}

進入_Block_copy源碼，將block 從棧區(qū)拷貝至堆區(qū)

• 如果需要釋放，如果需要則直接釋放

• 如果是globalBlock 不需要copy，直接返回

• 反之，只有兩種情況：棧區(qū)block or 堆區(qū)block，由于堆區(qū)block需要申請空間，前面并沒有申請空間的相關(guān)代碼，所以只能是棧區(qū)block，

  • 通過malloc申請內(nèi)存空間用于接收block
  • 通過memmove將block拷貝至新申請的內(nèi)存中
  • 設(shè)置block對象的類型為堆區(qū)block，即result->isa = _NSConcreteMallocBlock

_Block_object_assign 分析

想要分析block的三層copy，首先需要知道外部變量的種類有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF

// 注釋: Block 捕獲的外界變量的種類
// Runtime support functions used by compiler when generating copy/dispose helpers

// Values for _Block_object_assign() and _Block_object_dispose() parameters
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
    //經(jīng)過__block修飾的變量
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
    //weak 弱引用變量
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
    //返回的調(diào)用對象 - 處理block_byref內(nèi)部對象內(nèi)存會加的一個額外標(biāo)記，配合flags一起使用
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

而_Block_object_assign是在底層編譯代碼中，外部變量拷貝時調(diào)用的方法就是它

• 進入_Block_object_assign源碼

  • 如果是普通對象，則交給系統(tǒng)arc處理，并拷貝對象指針，即引用計數(shù)+1，所以外界變量不能釋放

  • 如果是block類型的變量，則通過_Block_copy操作，將block從棧區(qū)拷貝到堆區(qū)

  • 如果是__block修飾的變量，調(diào)用_Block_byref_copy函數(shù) 進行內(nèi)存拷貝以及常規(guī)處理

static struct Block_byref *_Block_byref_copy(const void *arg) {

    //強轉(zhuǎn)為Block_byref結(jié)構(gòu)體類型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申請內(nèi)存
        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;
        //block內(nèi)部持有的Block_byref 和 外界的Block_byref 所持有的對象是同一個，這也是為什么__block修飾的變量具有修改能力
        //copy 和 scr 的地址指針達到了完美的同一份拷貝，目前只有持有能力
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //如果有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
            //Block_byref_2是結(jié)構(gòu)體，__block修飾的可能是對象，對象通過byref_keep保存，在合適的時機進行調(diào)用
            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;
            }
            //等價于 __Block_byref_id_object_copy
            (*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;
}

• 進入_Block_byref_copy源碼

  • 將傳入的對象，強轉(zhuǎn)為Block_byref結(jié)構(gòu)體類型對象，保存一份

  • 沒有將外界變量拷貝到堆，需要申請內(nèi)存，其進行拷貝

  • 如果已經(jīng)拷貝過了，則進行處理并返回

  • 其中copy 和src的forwarding指針都指向同一片內(nèi)存，這也是為什么__block修飾的對象具有修改能力的原因

static struct Block_byref *_Block_byref_copy(const void *arg) {

    //強轉(zhuǎn)為Block_byref結(jié)構(gòu)體類型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申請內(nèi)存
        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;
        //block內(nèi)部持有的Block_byref 和 外界的Block_byref 所持有的對象是同一個，這也是為什么__block修飾的變量具有修改能力
        //copy 和 scr 的地址指針達到了完美的同一份拷貝，目前只有持有能力
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //如果有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
            //Block_byref_2是結(jié)構(gòu)體，__block修飾的可能是對象，對象通過byref_keep保存，在合適的時機進行調(diào)用
            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;
            }
            //等價于 __Block_byref_id_object_copy
            (*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;
}

代碼調(diào)試

• 定義一個__block修飾的NSString對象

 __block NSString * hj_name = [NSString stringWithFormat:@"HJ"];
void (^block1)(void) = ^{ // block_copy
    lg_name = @"HJ";
    NSLog(@"HJ - %@", hj_name);

    // block 內(nèi)存
};
block1();

• xcrun編譯結(jié)果如下，

  • 編譯后的hj_name比普通變量多了__Block_byref_id_object_copy_131 和 __Block_byref_id_object_dispose_131

  • __Block_byref_ hj_name_0結(jié)構(gòu)體中多了__Block_byref_id_object_copy和__Block_byref_id_object_dispose

//********編譯后的hj_name********
 __Block_byref_ hj_name_0 hj_name =
        {(void*)0,
            (__Block_byref_ hj_name_0 *)& hj_name,
            33554432,
            sizeof(__Block_byref_ hj_name_0),
            __Block_byref_id_object_copy_131,
            __Block_byref_id_object_dispose_131,
            ((NSString * _Nonnull (*)(id, SEL, NSString * _Nonnull, ...))(void *)objc_msgSend)((id)objc_getClass("NSString"), sel_registerName("stringWithFormat:"), (NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_0)};

//********__Block_byref_ hj_name_0結(jié)構(gòu)體********
struct __Block_byref_ hj_name_0 {
  void *__isa;
__Block_byref_ hj_name_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);  // 5*8 = 40
 NSString * hj_name;
};

 //********__Block_byref_id_object_copy_131********
 //block自身拷貝（_Block_copy） -- __block bref結(jié)構(gòu)體拷貝(_Block_object_assign) -- _Block_object_assign中對外部變量（存儲在bref）拷貝一份到內(nèi)存
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    //dst 外部捕獲的變量，即結(jié)構(gòu)體 - 5*8 = 40，然后就找到了cjl_name(cjl_name在bref初始化時就賦值了)
    _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}

 //********__Block_byref_id_object_dispose_131********
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

• 通過libclosure-74可編譯源碼斷點調(diào)試，關(guān)鍵方法的執(zhí)行順序為：_Block_copy -> _Block_byref_copy -> _Block_object_assign,正好對應(yīng)上述的三層copy

綜上所述，block是如何取到 hj_name的？

• 1、通過_Block_copy方法，將block拷貝一份至堆區(qū)

• 2、通過_Block_object_assign方法正常拷貝，因為__block修飾的外界變量在底層是 Block_byref結(jié)構(gòu)體

• 3、發(fā)現(xiàn)外部變量還存有一個對象，從bref中取出相應(yīng)對象hj_name，拷貝至block空間，才能使用（相同空間才能使用，不同則不能使用）。最后通過內(nèi)存平移就得到了hj_name，此時的hj_name 和 外界的hj_name是同一片內(nèi)存空間（從_Block_object_assign方法中的*dest = object;看出）

三層copy總結(jié)

所以，綜上所述，block的三層拷貝是指以下三層：

• 【第一層】通過_Block_copy實現(xiàn)對象的自身拷貝,從棧區(qū)拷貝至堆區(qū)

• 【第二層】通過_Block_byref_copy方法，將對象拷貝為Block_byref結(jié)構(gòu)體類型

• 【第三層】調(diào)用_Block_object_assign方法，對__block修飾的當(dāng)前變量的拷貝

注：只有__block修飾的對象，block的copy才有三層

_Block_object_dispose 分析

同一般的retain和release一樣，_Block_object_object其本質(zhì)主要是retain，所以對應(yīng)的還有一個release，即_Block_object_dispose方法，其源碼實現(xiàn)如下，也是通過區(qū)分block種類，進行不同釋放操作

// When Blocks or Block_byrefs hold objects their destroy helper routines call this entry point
// to help dispose of the contents 當(dāng)Blocks或Block_byrefs持有對象時，其銷毀助手例程將調(diào)用此入口點以幫助處置內(nèi)容
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://__block修飾的變量，即bref類型的
        // get rid of the __block data structure held in a Block
        _Block_byref_release(object);
        break;
      case BLOCK_FIELD_IS_BLOCK://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_byref_release源碼，主要就是對象、變量的釋放銷毀

static void _Block_byref_release(const void *arg) {
    //對象強轉(zhuǎn)為Block_byref類型結(jié)構(gòu)體
    struct Block_byref *byref = (struct Block_byref *)arg;

    // dereference the forwarding pointer since the compiler isn't doing this anymore (ever?)
    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) {//是否有拷貝輔助函數(shù)
                struct Block_byref_2 *byref2 = (struct Block_byref_2 *)(byref+1);
                (*byref2->byref_destroy)(byref);//銷毀拷貝對象
            }
            free(byref);//釋放
        }
    }
}

所以，綜上所述，Block的三層copy的流程如下圖所示