Block本質(zhì)上是一個OC對象，從底層結(jié)構(gòu)就可以看的出來內(nèi)部也有一個isa指針。
Block封裝了函數(shù)調(diào)用，以及函數(shù)調(diào)用環(huán)境(參數(shù)，訪問外面的值)的OC對象。

可以寫一個簡單的block，通過clang編譯器生成對應(yīng)的.cpp文件來看到對應(yīng)的block底層。
終端切到block代碼對應(yīng)文件的目錄下，敲如下：

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc block所在的文件名.m

1. Block底層結(jié)構(gòu)

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

通過以上代碼，生成對應(yīng)的.cpp,可以看到，Block底層的結(jié)構(gòu)。__block_impl這是個結(jié)構(gòu)體，就相當于block的第一個成員就是isa指針。也可以看出，block把外部變量包裝到了內(nèi)部。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;  //=> __main_block_desc_0
  int a;   // 外面定義的變量
  
  // C++構(gòu)造函數(shù)
  // a(_a) 將 a = _a; _a=10
 __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;
  }
};

_block_impl 結(jié)構(gòu)

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;  //指向block函數(shù)實現(xiàn)的指針
};

__main_block_desc_0 結(jié)構(gòu)

用來描述block

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;  // block結(jié)構(gòu)體大小
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

block函數(shù)實現(xiàn) __main_block_func_0()

這個函數(shù)的地址就是block內(nèi)部的FuncPtr

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int a = __cself->a; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_1qw3s7mx3dj1m3w2r4spjzp40000gn_T_main_9ad076_mi_1,a);
}

block調(diào)用

int main(int argc, const char * argv[]) {
 int a = 10;
 
// 定義block變量 
// 參數(shù)1:__main_block_func_0 
// 參數(shù)2：__main_block_desc_0_DATA
// 參數(shù)3：a變量
void (*myblock)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));

// 執(zhí)行block內(nèi)部代碼
// block->FuncPtr()
((void (*)(__block_impl *))((__block_impl *)myblock)->FuncPtr)((__block_impl *)myblock);

 return 0;
}

2. Block捕獲

block捕獲：block內(nèi)部會專門新增一個成員來存儲外部變量。

當block訪問局部變量，block就會捕獲

• 訪問auto變量原來是什么類型，捕捉的就是什么類型，如果捕捉的是基本數(shù)據(jù)類型，那就是值引用，直接存儲的變量的值。如果捕捉的是對象類型，那么就是對象的地址。

• 訪問static變量->指針傳遞，存儲的是局部變量的地址值。

auto自動變量，隨時都可能會銷毀，而static變量會一直在內(nèi)存中，所以可以存儲地址。全局變量一直在內(nèi)存中，且誰都可以用，所以block不用捕獲。

3. Block類型

從上面block的結(jié)構(gòu)可以看出有這樣一行代碼。block是什么類型，是什么對象就取決于block的isa指針指向。不管block是什么類型，都是NSBlock類型。isa指針本質(zhì)是來自于NSObject，因為block是個OC對象。

// _NSConcreteStackBlock -> NSStackBlock
impl.isa = &_NSConcreteStackBlock;

• NSGlobalBlock
  沒有訪問auto變量，且調(diào)用copy方法也不會做什么操作，依然還是NSGlobalBlock類型。

• NSStackBlock
  訪問了auto變量,內(nèi)存放在棧上。一旦離開了作用域，block就可能被銷毀。這樣在外面訪問的時候就可能會出現(xiàn)問題。

• NSMallocBlock
  最常用。NSStackBlock調(diào)用copy方法就會變成NSMallocBlock。如果堆上的block進行copy操作的話，引用計數(shù)器會增加。

在開發(fā)中，經(jīng)常要對block進行copy操作，希望保住block的命。這也是為什么block作為屬性時修飾詞要用copy。ARC會根據(jù)情況??自動把棧上的Block拷貝copy到堆上變成NSMallocBlock類型。

gcd里面的block
當有強指針指向Block時
Foundation框架中含有usingBlock字眼的block
將block作為返回值時

4. Block內(nèi)存管理

循環(huán)引用: 互相強引用導(dǎo)致無法釋放。

不管是MRC還是ARC，棧上的Block是不會擁有外面的對象。即不管捕獲的對象是強指針指向還是弱指針指向，都無法保住它的命。堆上的Block可以。

ARC中
堆上的Block內(nèi)部會根據(jù)捕獲對象此時指向的指針類型(強指針，還是弱指針__weak修飾)來定義內(nèi)部的對象類型(是強指針還是弱指針指向)。如果捕獲的對象是指針指向的話，__main_block_desc_0 會新增兩個方法copy()和dispose()。這也是為什么__weak能夠解決循環(huán)引用。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  // 這個是weak還是strong是根據(jù)外面?zhèn)鬟M來的是weak還是strong
  NSObject *__weak weakObj;
  
  ...
};

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_func_0

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
NSObject *__weak weakObj = __cself->weakObj; // bound by copy

        NSLog((NSString *)&__NSConstantStringImpl__var_folders_6y_1qw3s7mx3dj1m3w2r4spjzp40000gn_T_main_bbffa5_mi_1,weakObj);
    }
    
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->weakObj, (void*)src->weakObj, 3/*BLOCK_FIELD_IS_OBJECT*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->weakObj, 3/*BLOCK_FIELD_IS_OBJECT*/);}

__block

__block 修飾，block內(nèi)部就可以修改auto變量。
__block 可以解決循環(huán)引用。ARC和MRC。

__block不會修改變量的性質(zhì)，也就是自動變量還是自動變量。__block不能修飾static變量，也不能修飾全局變量，只能修飾auto變量。一旦用__block修飾的變量，編譯器會把這個變量包裝成一個對象。

前提是在堆上的Block:
ARC中block內(nèi)部會對這個對象進行強引用。__block也能解決ARC環(huán)境中的循環(huán)引用問題，但是一定要調(diào)用block，并且在block內(nèi)部要將對象置為nil。這樣看來也是不安全的，因為不確定block是否會被執(zhí)行，什么時候執(zhí)行。

MRC中，__block修飾的變量，block內(nèi)部是不會對其進行強引用的，所以在MRC中__block也可以用來解決循環(huán)引用。

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  
  // 把基本數(shù)據(jù)a包裝成一個對象a，并且不管外面?zhèn)鞯氖莣eak還是strong
  // 只要用__block修飾，block內(nèi)部就會對這個對象進行強引用
  // 前提是堆上的block
    __Block_byref_a_0 *a; 
    
  ...
};

__Block_byref_a_0

__forwarding這個指針指向的是block本身那為什么還需要這個指針呢？因為block被拷貝到堆上的時候，會讓棧上__block結(jié)構(gòu)體中__forwarding指針指向堆上的block，保證數(shù)據(jù)正確。

struct __Block_byref_a_0 {
  void *__isa;

  // __forwarding指向block本身
__Block_byref_a_0 *__forwarding;

 int __flags;
 int __size;
 
 // 這里的變量類型也是根據(jù)傳入進的類型而定
 // 如果傳入的是對象類型，
 // 那么這里也是根據(jù)傳入的對象的指針強弱定義這里變量的強弱指向
 // 從這個角度也可以看__weak可以解決循環(huán)引用的問題
 int a; 
 
 // 如果傳入的是對象這里也會多兩個方法copy()和dispose()
 // 要對傳入對象進行內(nèi)存管理
 ...
 
};

__weak & __unsafe_unretained

都可以解決循環(huán)引用的問題。區(qū)別就在于當對象銷毀時的處理方式不一樣。__unsafe_unretained是不安全的。在MRC中__weak這個關(guān)鍵字用不了。