老生常談之Block

老生常談之Block

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

Block的實現(xiàn)

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

#import <stdio.h>

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

這個是我們最常見的C代碼，導(dǎo)入stdio.h，然后打印出來Hello World。接下來我們寫一個最簡單的block，沒有返回值，沒有傳入?yún)?shù)：

#import <stdio.h>

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

打印出來的結(jié)果相當(dāng)于調(diào)用了blk輸出的結(jié)果。接下來我們在item中跳轉(zhuǎn)到main.m所在文件夾然后執(zhí)行如下命令：

clang -rewrite-objc main.m

你會發(fā)現(xiàn)在當(dāng)前文件夾下生成了一個.cpp文件，它是經(jīng)過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;
}

其中包含三個結(jié)構(gòu)體：

__main_block_impl_0、__block_impl、__main_block_desc_0

和兩個方法：

__main_block_func_0、main

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

^{printf("Hello Worldddd")};

變換后的源代碼如下：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {

        printf("Hello Worldddd");
    }

也就是現(xiàn)在變成了一個靜態(tài)方法，其命名方式為：Block所屬的函數(shù)名(main)和該Block語法在函數(shù)出現(xiàn)的順序值(0)來給經(jīng)過clang變換的函數(shù)命名。該方法的參數(shù)相當(dāng)于我們在OC里面的指向自身的self。我們看一下該參數(shù)的聲明：

struct __main_block_impl_0 *__cself

你會發(fā)現(xiàn)它其實是一個結(jié)構(gòu)體，該結(jié)構(gòu)體的聲明如下：

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

該結(jié)構(gòu)體中你會發(fā)現(xiàn)里面有一個構(gòu)造函數(shù)，你忽略構(gòu)造函數(shù)，會發(fā)現(xiàn)該結(jié)構(gòu)體就很簡單了，只是包含了impl和 Desc兩個屬性變量。其中impl也是一個結(jié)構(gòu)體，它的結(jié)構(gòu)如下：

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

從屬性變量的名字我們可以猜測出該結(jié)構(gòu)體各個屬性的含義：

  1. isa：isa指針，指向父類的指針。
  2. Flags：一個標(biāo)記
  3. Reserved：預(yù)留區(qū)域，用于以后的使用。
  4. FuncPtr：這個很重要，是一個函數(shù)指針。后面會詳細(xì)說明它的作用。

第二個變量是Desc，也是一個結(jié)構(gòu)體：

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

這個結(jié)構(gòu)體就比較簡單了，一個預(yù)留位，一個是指代該Block大小的屬性，后面又包含了一個該實例：

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

預(yù)留位為0，大小為傳入結(jié)構(gòu)體的大小。接下來就是很重要的構(gòu)造函數(shù)了：

 __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是構(gòu)造函數(shù)傳過來的fp函數(shù)指針；Desc為一個block的描述。到這里三個結(jié)構(gòu)體和一個函數(shù)就介紹完了。接下來看一下main函數(shù)里面上述構(gòu)造函數(shù)是如何調(diào)用的：

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

感覺好復(fù)雜，我們先做一個轉(zhuǎn)換：

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;

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

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

現(xiàn)在在看一下調(diào)用block的那句代碼：

blk();

轉(zhuǎn)換成了：

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

這個轉(zhuǎn)換不是太明白，但是知道他的作用就是把blk當(dāng)做參數(shù)傳進(jìn)去，調(diào)用的FuncPtr所指向的函數(shù)，也就是__ block _ block _ func _ 0。

到這里就大體了解了Block的實現(xiàn)，其實就是C的幾個結(jié)構(gòu)體和方法，經(jīng)過賦值和調(diào)用，進(jìn)而實現(xiàn)了Block。
另外Block其實實質(zhì)上也是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函數(shù)調(diào)用的時候把i傳到了構(gòu)造函數(shù)里，然后通過i(_i)對結(jié)構(gòu)體的屬性變量i賦值，i變量現(xiàn)在已經(jīng)成為了結(jié)構(gòu)體的一個樹形變量。在構(gòu)造函數(shù)執(zhí)行時把i賦值。在 __ main _ block_func _ 0里面通過 __ cself調(diào)用，這個變量實際是在聲明block時，被復(fù)制到了結(jié)構(gòu)體變量i，因此不會影響變量i的值。當(dāng)我們嘗試在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;
}

運(yùn)行一下你會發(fā)現(xiàn)你成功對i的值進(jìn)行了修改！用clang進(jìn)行編譯，結(jié)果如下:

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

你會發(fā)現(xiàn)多了一個__ Block _ byref _i _ 0的結(jié)構(gòu)體，然后多了兩個copy和dispose函數(shù)。
看一下main函數(shù)里面的i，此時也不再是一個簡單的基本類型int，而是一個初始化的 __ Block _ byref _ i _ 0的結(jié)構(gòu)體，該結(jié)構(gòu)體有個屬性變量為i，然后把3賦值給了那個屬性變量。該結(jié)構(gòu)體還有一個指向自己的指針 __ forwarding，它被賦值為i的地址。
現(xiàn)在 __ main _ block _ func _ 0在實現(xiàn)中使用了指向該變量的指針，所以達(dá)到了修改外部變量的作用。

Block的存儲域

Block的存儲域有以下幾種：

  1. _ NSConcreteStackBlock,該類的對象Block設(shè)置在棧上
  2. _ NSConcreteGlobalBlock,該類的Block設(shè)置在程序的數(shù)據(jù)區(qū)(.data)域中。
  3. _ NSConcreteMallocBlcok,該類的Block設(shè)置在堆上
    下面這張圖展示了Block的存儲域:
Block的存儲域

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


堆上的block

還有一種情況是Global的block：


global的block

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

此時我們也許會有個疑問：Block超出了變量作用域為什么還能存在呢？
對于Global的Block，變量作用域之外也可以通過指針安全使用，但是設(shè)置在棧上的就比較尷尬了，作用域結(jié)束后，Block也會 被廢棄。為了使Block超出變量作用域還可以存在，Block提供了將Block和 __ block變量從棧上復(fù)制到堆上的方法來解決這個問題。這樣就算棧上的廢棄，堆上的Block還可以繼續(xù)存在。

看一下對Block進(jìn)行復(fù)制，結(jié)果如何：

Block進(jìn)行copy操作

如果對Block進(jìn)行了copy操作，__ block的變量也會受到影響，當(dāng) __ block的變量配置在棧上，復(fù)制之后它將從棧復(fù)制到堆上并被Blcok持有，如果是堆上的 __ block變量，Blcok復(fù)制之后該變量被Block持有。
如果兩個block（block1,block2）同時都是用 __ block變量，如果block1被復(fù)制到了堆上，那么 __ block變量也會在block1復(fù)制到堆的同時復(fù)制到堆上，當(dāng)block2再是用到 __ block變量的時候，只是增加堆上 __ block變量的引用計數(shù)，不會再次復(fù)制。如果堆上的block1和block2被廢棄了，那么它所是用的 __ block變量也就被釋放了（如果block1被廢棄，而block2沒有被廢棄，那么 __ block變量的引用計數(shù)-1，直到最后使用 __ block變量的block被廢棄的同時，堆上的 __ block也會被釋放）。
理解了上面剛才說的復(fù)制之后，現(xiàn)在回過來思考另一個問題： __ block的時候轉(zhuǎn)換的結(jié)構(gòu)體中的 __ forwarding指針有什么作用呢？（下面代碼中的 __ forwarding）

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

其實是這樣的：棧上的 __ block變量用結(jié)構(gòu)體實例在 __ block變量從棧復(fù)制到堆上的時候，會將成員變量 __ forwarding的值替換為復(fù)制目標(biāo)堆上的 __ block變量用結(jié)構(gòu)體實例的地址。通過該操作之后，無論是在Block語法中、Block語法外使用 __ block變量，還是 __ block變量配置在棧上或者堆上，都可以順利地訪問同一個 __ block變量。

以上便是對block的進(jìn)一步介紹，主要參考了《Objective-C高級編程 iOS與OS X多線程和內(nèi)存管理》一書。

轉(zhuǎn)贊請注明來源：http://m.itdecent.cn/p/c7c8ad987e5e

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

友情鏈接更多精彩內(nèi)容