老生常談之Block_ZenDei技術網路在線

這篇博客主要更加深入地瞭解一下Block。包括：Block的實現、__Block的原理以及Block的存儲域三方面。 ...

前面有一篇介紹Block的博客，主要介紹了Block的簡單使用技巧。這篇博客主要更加深入地瞭解一下Block。包括：Block的實現、__Block的原理以及Block的存儲域三方面。

Block的實現

首先我們使用Xcode創建一個Project,點擊File-->New-->Project，選擇macOS中Application的Command Line Tool，然後設置Project Name即可。你好發現這個工程值包含了一個main.m文件，然後我們做如下更改（更改後的代碼如下）：

#import <stdio.h>

int main(int argc, const char * argv[]) {
    printf("Hello World");
    return 0;
}

這個是我們最常見的C代碼，導入stdio.h，然後列印出來Hello World。接下來我們寫一個最簡單的block，沒有返回值，沒有傳入參數：

#import <stdio.h>

int main(int argc, const char * argv[]) {
    
    void (^blk)(void) = ^{
        printf("Hello Worldddd");
    };
    blk();
    return 0;
}

列印出來的結果相當於調用了blk輸出的結果。接下來我們在item中跳轉到main.m所在文件夾然後執行如下命令：

clang -rewrite-objc main.m

你會發現在當前文件夾下生成了一個.cpp文件，它是經過clang編譯器編譯之後的文件，打開之後裡面大概有5百多行，其實我們看下麵的這些代碼就足夠了：

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;
  }
};
#ifndef BLOCK_IMPL
#define BLOCK_IMPL
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

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[]) {

    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

其中包含三個結構體：

__main_block_impl_0、__block_impl、__main_block_desc_0

和兩個方法：

__main_block_func_0、main

main就是我們寫的main函數。
至此，你能知道的就是：Block看上去很特別，其實就是作為及其普通的C語言源代碼來處理的。編譯器會把Block的源代碼轉換成一般的C語言編譯器能處理的源代碼，並作為極為普通的C語言源代碼被編譯。
接下來對編譯的內容來一個分解，首先是

^{printf("Hello Worldddd")};

變換後的源代碼如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

也就是現在變成了一個靜態方法，其命名方式為：Block所屬的函數名(main)和該Block語法在函數出現的順序值(0)來給經過clang變換的函數命名。該方法的參數相當於我們在OC裡面的指向自身的self。我們看一下該參數的聲明：

struct __main_block_impl_0 *__cself

你會發現它其實是一個結構體，該結構體的聲明如下：

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

該結構體中你會發現裡面有一個構造函數，你忽略構造函數，會發現該結構體就很簡單了，只是包含了impl和 Desc兩個屬性變數。其中impl也是一個結構體，它的結構如下：

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

從屬性變數的名字我們可以猜測出該結構體各個屬性的含義：

isa：isa指針，指向父類的指針。
Flags：一個標記
Reserved：預留區域，用於以後的使用。
FuncPtr：這個很重要，是一個函數指針。後面會詳細說明它的作用。

第二個變數是Desc，也是一個結構體：

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

這個結構體就比較簡單了，一個預留位，一個是指代該Block大小的屬性，後面又包含了一個該實例：

__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

預留位為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;
  }

其中的&_NSConcreteStackBlock用於初始化impl的isa指針；flags為0；FuncPtr是構造函數傳過來的fp函數指針；Desc為一個block的描述。到這裡三個結構體和一個函數就介紹完了。接下來看一下main函數裡面上述構造函數是如何調用的：

 void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

感覺好複雜，我們先做一個轉換：

struct __main_block_impl_0 tmpeImpl = __main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)

struct __main_block_impl_0 *blk = &tmpeImpl;

也就是說把結構體的實例的指針賦值給blk。接下來再看一下構造函數的的初始化，其實賦值就變成了這樣：

impl.isa = &_NSConcreteStackBLock;
impl.Flags = 0;
impl.FuncPtr = __main_block_func_0;
Desc = &__main_block_desc_0_DATA;

現在在看一下調用block的那句代碼：

blk();

轉換成了：

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

這個轉換不是太明白，但是知道他的作用就是把blk當做參數傳進去，調用的FuncPtr所指向的函數，也就是__ block _ block _ func _ 0。

到這裡就大體瞭解了Block的實現，其實就是C的幾個結構體和方法，經過賦值和調用，進而實現了Block。
另外Block其實實質上也是OC的對象。

__Block的原理
先看一個簡單的例子：

#import <stdio.h>

int main(int argc, const char * argv[]) {
    int i = 3;
    void (^blk)(void) = ^{
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

使用clang編譯後是這樣的：


struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int i;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _i, int flags=0) : i(_i) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int i = __cself->i; // bound by copy

        printf("Hello World,%d",i);
    }

int main(int argc, const char * argv[]) {
    int i = 3;
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, i));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

也就是在main函數調用的時候把i傳到了構造函數里，然後通過i(_i)對結構體的屬性變數i賦值，i變數現在已經成為了結構體的一個樹形變數。在構造函數執行時把i賦值。在 main _ block_func _ 0裡面通過 cself調用，這個變數實際是在聲明block時，被覆制到了結構體變數i，因此不會影響變數i的值。當我們嘗試在Block中去修改時，你會得到如下錯誤：

Variable is not assignable(missing __block type specifier)

提示我們加上__block,接下來我們將源代碼做如下修改：

int main(int argc, const char * argv[]) {
    __block int i = 3;
    void (^blk)(void) = ^{
        i = i + 3;
        printf("Hello World,%d",i);
    };
    blk();
    return 0;
}

運行一下你會發現你成功對i的值進行了修改！用clang進行編譯，結果如下:

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_i_0 *i; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_i_0 *_i, int flags=0) : i(_i->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_i_0 *i = __cself->i; // bound by ref

        (i->__forwarding->i) = (i->__forwarding->i) + 3;
        printf("Hello World,%d",(i->__forwarding->i));
    }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->i, (void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->i, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

int main(int argc, const char * argv[]) {
    __attribute__((__blocks__(byref))) __Block_byref_i_0 i = {(void*)0,(__Block_byref_i_0 *)&i, 0, sizeof(__Block_byref_i_0), 3};
    void (*blk)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_i_0 *)&i, 570425344));
    ((void (*)(__block_impl *))((__block_impl *)blk)->FuncPtr)((__block_impl *)blk);
    return 0;
}

你會發現多了一個__ Block _ byref i 0的結構體，然後多了兩個copy和dispose函數。
看一下main函數裡面的i，此時也不再是一個簡單的基本類型int，而是一個初始化的 __ Block _ byref _ i _ 0的結構體，該結構體有個屬性變數為i，然後把3賦值給了那個屬性變數。該結構體還有一個指向自己的指針 __ forwarding，它被賦值為i的地址。
現在 __ main _ block _ func _ 0在實現中使用了指向該變數的指針，所以達到了修改外部變數的作用。

Block的存儲域

Block的存儲域有以下幾種：

_ NSConcreteStackBlock,該類的對象Block設置在棧上
_ NSConcreteGlobalBlock,該類的Block設置在程式的數據區(.data)域中。
_ NSConcreteMallocBlcok,該類的Block設置在堆上
下麵這張圖展示了Block的存儲域:

Block的存儲域

我們前面看到的都是在Stack的Block，但是你可以在OC工程中列印一下你聲明的block的isa，你會發現它其實是Malloc的block，也就是在堆上的block。如圖：

還有一種情況是Global的block：

在ARC中，只有NSConcreteGlobalBlock和NSConcreteMallockBlock兩種類型的block。因為我們最簡單的block在工程中列印出來的都是MallocBlock。也許是因為蘋果把對象都放到了堆管理，而Block也是對象，所以也放到了堆上。

此時我們也許會有個疑問：Block超出了變數作用域為什麼還能存在呢？
對於Global的Block，變數作用域之外也可以通過指針安全使用，但是設置在棧上的就比較尷尬了，作用域結束後，Block也會被廢棄。為了使Block超出變數作用域還可以存在，Block提供了將Block和 __ block變數從棧上複製到堆上的方法來解決這個問題。這樣就算棧上的廢棄，堆上的Block還可以繼續存在。

看一下對Block進行複製，結果如何：
Block進行copy操作
如果對Block進行了copy操作，__ block的變數也會受到影響，當 __ block的變數配置在棧上，複製之後它將從棧複製到堆上並被Blcok持有，如果是堆上的 __ block變數，Blcok複製之後該變數被Block持有。
如果兩個block（block1,block2）同時都是用 __ block變數，如果block1被覆制到了堆上，那麼 __ block變數也會在block1複製到堆的同時複製到堆上，當block2再是用到 __ block變數的時候，只是增加堆上 __ block變數的引用計數，不會再次複製。如果堆上的block1和block2被廢棄了，那麼它所是用的 __ block變數也就被釋放了（如果block1被廢棄，而block2沒有被廢棄，那麼 __ block變數的引用計數-1，直到最後使用 __ block變數的block被廢棄的同時，堆上的 __ block也會被釋放）。
理解了上面剛纔說的複製之後，現在回過來思考另一個問題： __ block的時候轉換的結構體中的 __ forwarding指針有什麼作用呢？（下麵代碼中的 __ forwarding）

struct __Block_byref_i_0 {
  void *__isa;
__Block_byref_i_0 *__forwarding;
 int __flags;
 int __size;
 int i;
};

其實是這樣的：棧上的 __ block變數用結構體實例在 __ block變數從棧複製到堆上的時候，會將成員變數 __ forwarding的值替換為複製目標堆上的 __ block變數用結構體實例的地址。通過該操作之後，無論是在Block語法中、Block語法外使用 __ block變數，還是 __ block變數配置在棧上或者堆上，都可以順利地訪問同一個 __ block變數。

以上便是對block的進一步介紹，主要參考了《Objective-C高級編程 iOS與OS X多線程和記憶體管理》一書。

轉載請標明來源：http://www.cnblogs.com/zhanggui/p/8135790.html