• 1: 什么是block？

  • 1.0: Block的語(yǔ)法
  • 1.1: block編譯轉(zhuǎn)換結(jié)構(gòu)
  • 1.2: block實(shí)際結(jié)構(gòu)

• 2: block的類型

  • 2.1: NSConcreteGlobalBlock和NSConcreteStackBlock
  • 2.2: NSConcreteMallocBlock

• 3: 捕捉變量對(duì)block結(jié)構(gòu)的影響

  • 3.1: 局部變量
  • 3.2: 全局變量
  • 3.3: 局部靜態(tài)變量
  • 3.4: __block修飾的變量
  • 3.5: self隱式循環(huán)引用

• 4: 不同類型block的復(fù)制

  • 4.1: 棧block
  • 4.2: 堆block
  • 4.3: 全局block

• 5: block輔助函數(shù)

  • 5.1: __block修飾的基本類型的輔助函數(shù)
  • 5.2: 對(duì)象的輔助函數(shù)

• 6: ARC中block的工作

  • 6.1: block試驗(yàn)
  • 6.2: block作為參數(shù)傳遞
  • 6.3: block作為返回值
  • 6.4: block屬性

• 7: 參考博文

1: 什么是block？

Block是C語(yǔ)言的擴(kuò)充功能， C語(yǔ)言中為了調(diào)用函數(shù)， 我們， 必須使用該函數(shù)的名稱func

int result = func(100);

當(dāng)然我們可以函數(shù)指針調(diào)用

int (*funcPstr) (int) = &func;
int result = (*funcPstr)(10);

通過(guò)Blocks， 源代碼就能夠使用匿名函數(shù), 不帶名稱的函數(shù)

1.0: Block的語(yǔ)法

完整的形式的block語(yǔ)法和C語(yǔ)言函數(shù)定義相比, 僅有兩點(diǎn)不同。

• 1：沒(méi)有函數(shù)名, 匿名函數(shù)或者函數(shù)指針理解就可以了
• 2： 帶有 ^.便于區(qū)分

^ 返回值類型 參數(shù)列表 表達(dá)式

例如：

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

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        ^{ };
    }
    return 0;
}

1.1: block編譯轉(zhuǎn)換結(jié)構(gòu)

對(duì)其執(zhí)行clang -rewrite-objc編譯轉(zhuǎn)換成C++實(shí)現(xiàn)，得到以下代碼：

struct __block_impl {
  void *isa;
  int Flags;
  int Reserved;
  void *FuncPtr;
};
 
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;
  }
};

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
}

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, char const *argv[])
{
 ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
 return 0;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { 0, 2 };

其中的__main_block_impl_0就是block的一個(gè)C++的實(shí)現(xiàn)

1: 其中__block_impl的定義如下：其結(jié)構(gòu)體成員如下：

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

• 1: isa，指向所屬類的指針，也就是block的類型
• 2: flags，標(biāo)志變量，在實(shí)現(xiàn)block的內(nèi)部操作時(shí)會(huì)用到
• 3: Reserved，保留變量
• 4: FuncPtr，block執(zhí)行時(shí)調(diào)用的函數(shù)指針
  可以看出，它包含了isa指針, 也就是說(shuō)block也是一個(gè)對(duì)象(runtime里面，對(duì)象和類都是用結(jié)構(gòu)體表示)。

**2: __main_block_desc_0的定義如下: **

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)成員含義如下：

• 1: reserved：保留字段
• 2: Block_size：block大小(sizeof(struct __main_block_impl_0))

代碼在定義__main_block_desc_0結(jié)構(gòu)體時(shí)，同時(shí)創(chuàng)建了__main_block_desc_0_DATA，并給它賦值，以供在main函數(shù)中對(duì)__main_block_impl_0進(jìn)行初始化。

3: __main_block_impl_0定義了顯式的構(gòu)造函數(shù)，其函數(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;
  }

• 1: __main_block_impl_0的isa指針指向了_NSConcreteStackBlock，
• 2: 從main函數(shù)中看， __main_block_impl_0的FuncPtr指向了函數(shù)__main_block_func_0
• 3: __main_block_impl_0的Desc也指向了定義__main_block_desc_0時(shí)就創(chuàng)建的__main_block_desc_0_DATA，其中紀(jì)錄了block結(jié)構(gòu)體大小等信息。

根據(jù)編譯轉(zhuǎn)換的結(jié)果，對(duì)一個(gè)簡(jiǎn)單block的解析，后面會(huì)將block操作不同類型的外部變量，對(duì)block結(jié)構(gòu)的影響進(jìn)行相應(yīng)的說(shuō)明。

1.2: block實(shí)際結(jié)構(gòu)

接下來(lái)觀察下Block_private.h文件中對(duì)block的相關(guān)結(jié)構(gòu)體的真實(shí)定義：

/* Revised new layout. */
struct Block_descriptor {
    unsigned long int reserved;
    unsigned long int size;
    void (*copy)(void *dst, void *src);
    void (*dispose)(void *);
};


struct Block_layout {
    void *isa;
    int flags;
    int reserved;
    void (*invoke)(void *, ...);
    struct Block_descriptor *descriptor;
    /* Imported variables. */
};

有了上文對(duì)編譯轉(zhuǎn)換的分析，這里只針對(duì)略微不同的成員進(jìn)行分析：

• 1: invoke，同上文的FuncPtr，block執(zhí)行時(shí)調(diào)用的函數(shù)指針，block定義時(shí)內(nèi)部的執(zhí)行代碼都在這個(gè)函數(shù)中
• 2: Block_descriptor，block的詳細(xì)描述.
  • copy/dispose，輔助拷貝/銷毀函數(shù)，處理block范圍外的變量時(shí)使用

總體來(lái)說(shuō)，block就是一個(gè)里面存儲(chǔ)了指向函數(shù)體中包含定義block時(shí)的代碼塊的函數(shù)指針，以及block外部上下文變量等信息的結(jié)構(gòu)體。

2: block的類型

block的常見(jiàn)類型有3種：

• 1: _NSConcreteGlobalBlock（全局）
• 2: _NSConcreteStackBlock（棧）
• 3: _NSConcreteMallocBlock（堆）

http://upload-images.jianshu.io/upload_images/608238-2393520e3fec4271.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240

由于無(wú)法直接創(chuàng)建_NSConcreteMallocBlock類型的block，所以這里只對(duì)前面2種進(jìn)行手動(dòng)創(chuàng)建分析，最后1種通過(guò)源代碼分析。

2.1 NSConcreteGlobalBlock和NSConcreteStackBlock(全局和棧區(qū)的block)

// 全局block
void (^globalBlock)() = ^{

};


int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 棧block
        void (^stackBlock1)() = ^{

        };
    }
    return 0;
}

對(duì)其進(jìn)行編譯轉(zhuǎn)換后得到以下縮略代碼:

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

// globalBlock的實(shí)現(xiàn)
struct __globalBlock_block_impl_0 {
  struct __block_impl impl;
  struct __globalBlock_block_desc_0* Desc;
  __globalBlock_block_impl_0(void *fp, struct __globalBlock_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteGlobalBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// globalBlock的方法
static void __globalBlock_block_func_0(struct __globalBlock_block_impl_0 *__cself) {


}

// globalBlock的描述
static struct __globalBlock_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __globalBlock_block_desc_0_DATA = { 0, sizeof(struct __globalBlock_block_impl_0)};
static __globalBlock_block_impl_0 __global_globalBlock_block_impl_0((void *)__globalBlock_block_func_0, &__globalBlock_block_desc_0_DATA);
void (*globalBlock)() = ((void (*)())&__global_globalBlock_block_impl_0);


// mainBlock的棧block
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;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
}

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
        void (*stackBlock1)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    }
    return 0;
}

• 1: 可以看出globalBlock的isa指向了_NSConcreteGlobalBlock，即在全局區(qū)域創(chuàng)建，編譯時(shí)具體的代碼就已經(jīng)確定在上圖中的代碼段中了，block變量存儲(chǔ)在全局?jǐn)?shù)據(jù)存儲(chǔ)區(qū)；
• 2: stackBlock的isa指向了_NSConcreteStackBlock，即在棧區(qū)創(chuàng)建。

2.2 NSConcreteMallocBlock

堆中的block，堆中的block無(wú)法直接創(chuàng)建，其需要由_NSConcreteStackBlock類型的block拷貝而來(lái)(也就是說(shuō)block需要執(zhí)行copy之后才能存放到堆中)。由于block的拷貝最終都會(huì)調(diào)用_Block_copy_internal函數(shù)，所以觀察這個(gè)函數(shù)就可以知道堆中block是如何被創(chuàng)建的了：

static void *_Block_copy_internal(const void *arg, const int flags) {
    struct Block_layout *aBlock;
    ...
    aBlock = (struct Block_layout *)arg;
    ...
    // Its a stack block.  Make a copy.
    if (!isGC) {
        // 申請(qǐng)block的堆內(nèi)存
        struct Block_layout *result = malloc(aBlock->descriptor->size);
        if (!result) return (void *)0;
        // 拷貝棧中block到剛申請(qǐng)的堆內(nèi)存中
        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK);    // XXX not needed
        result->flags |= BLOCK_NEEDS_FREE | 1;
        // 改變isa指向_NSConcreteMallocBlock，即堆block類型
        result->isa = _NSConcreteMallocBlock;
        if (result->flags & BLOCK_HAS_COPY_DISPOSE) {
            //printf("calling block copy helper %p(%p, %p)...\n", aBlock->descriptor->copy, result, aBlock);
            (*aBlock->descriptor->copy)(result, aBlock); // do fixup
        }
        return result;
    }
    else {
        ...
    }
}

從以上代碼以及注釋可以很清楚的看出，函數(shù)通過(guò)memmove將棧中的block的內(nèi)容拷貝到了堆中，并使isa指向了_NSConcreteMallocBlock。
block主要的一些學(xué)問(wèn)就出在棧中block向堆中block的轉(zhuǎn)移過(guò)程中了。

3: 捕捉變量對(duì)block結(jié)構(gòu)的影響

接下來(lái)會(huì)編譯轉(zhuǎn)換捕捉不同變量類型的block，以對(duì)比它們的區(qū)別。

3.1 局部變量

• 前：

- (void)test
{
    int a;
    ^{a;};
}

• 后:

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

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  __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;
  }
};

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

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 
       int a;
     ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a));
    }
    return 0;
}

可以看到，block相對(duì)于文章開(kāi)頭增加了一個(gè)int類型的成員變量，他就是用來(lái)存儲(chǔ)外部變量a的?？梢钥闯觯@次拷貝只是一次值傳遞。并且當(dāng)我們想在block中進(jìn)行以下操作時(shí)，將會(huì)發(fā)生錯(cuò)誤

^{a = 10;};

http://upload-images.jianshu.io/upload_images/608238-712f1c798d842cbd.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240

在block對(duì)a進(jìn)行賦值是沒(méi)有意義的，所以編譯器給出了錯(cuò)誤。我們可以通過(guò)地址傳遞來(lái)消除以上錯(cuò)誤：

- (void)test
{
    int a = 0;
    // 利用指針p存儲(chǔ)a的地址
    int *p = &a;

    ^{
        // 通過(guò)a的地址設(shè)置a的值
        *p = 10;
    };
}

但是變量a的生命周期是和方法test的棧相關(guān)聯(lián)的，當(dāng)test運(yùn)行結(jié)束，棧隨之銷毀，那么變量a就會(huì)被銷毀，p也就成為了野指針。如果block是作為參數(shù)或者返回值，這些類型都是跨棧的，也就是說(shuō)再次調(diào)用會(huì)造成野指針錯(cuò)誤。

3.2 全局變量

• 1: 前：

// 全局靜態(tài)
static int a;
// 全局
int b;
- (void)test
{

    ^{
        a = 10;
        b = 10;
    };
}

• 2: 后：

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

static int a;

int b;

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

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
        a = 10;
        b = 10;
}

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 (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
    return 0;
}

可以看出，因?yàn)槿肿兞慷际窃陟o態(tài)數(shù)據(jù)存儲(chǔ)區(qū)，在程序結(jié)束前不會(huì)被銷毀，所以block直接訪問(wèn)了對(duì)應(yīng)的變量，而沒(méi)有在Persontest_block_impl_0結(jié)構(gòu)體中給變量預(yù)留位置。

3.3 局部靜態(tài)變量

• 1: 前:

- (void)test
{
    static int a;
    ^{
        a = 10;
    };
}

• 2: 后：

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

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int *a;
  __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;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  int *a = __cself->a; // bound by copy

        (*a) = 10;
    }

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

   static int a;
    ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, &a));
    return 0;
}

靜態(tài)局部變量是存儲(chǔ)在靜態(tài)數(shù)據(jù)存儲(chǔ)區(qū)域的，也就是和程序擁有一樣的生命周期，也就是說(shuō)在程序運(yùn)行時(shí)，都能夠保證block訪問(wèn)到一個(gè)有效的變量。但是其作用范圍還是局限于定義它的函數(shù)中，所以只能在block通過(guò)靜態(tài)局部變量的地址來(lái)進(jìn)行訪問(wèn)。

3.4 __block修飾的變量

• 1: 前：

- (void)test
{
   __block int a;
    ^{
        a = 10;
    };
}

• 2: 后：

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

struct __main_block_impl_0 {
  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) {
    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_a_0 *a = __cself->a; // bound by ref
        (a->__forwarding->a) = 10;
}

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

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_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0)};
;
    ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
    return 0;
}

對(duì)比上面的結(jié)果多了__Block_byref_a_0結(jié)構(gòu)體，這個(gè)結(jié)構(gòu)體中含有isa指針，所以也是一個(gè)對(duì)象，它是用來(lái)包裝局部變量a的。當(dāng)block被copy到堆中時(shí)，__Person__test_block_impl_0的拷貝輔助函數(shù)__Person__test_block_copy_0會(huì)將__Block_byref_a_0拷貝至堆中，所以即使局部變量所在堆被銷毀，block依然能對(duì)堆中的局部變量進(jìn)行操作。其中__Block_byref_a_0成員指針__forwarding用來(lái)指向它在堆中的拷貝，其依據(jù)源碼如下：

static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
    struct Block_byref **destp = (struct Block_byref **)dest;
    struct Block_byref *src = (struct Block_byref *)arg;

    ...
    // 堆中拷貝的forwarding指向它自己
    copy->forwarding = copy; // patch heap copy to point to itself (skip write-barrier)
    // 棧中的forwarding指向堆中的拷貝
    src->forwarding = copy;  // patch stack to point to heap copy
    ...
}

為了保證操作的值始終是堆中的拷貝，而不是棧中的值。（處理在局部變量所在棧還沒(méi)銷毀，就調(diào)用block來(lái)改變局部變量值的情況，如果沒(méi)有__forwarding指針，則修改無(wú)效）
至于block如何實(shí)現(xiàn)對(duì)局部變量的拷貝，下面會(huì)詳細(xì)說(shuō)明。

3.5: self隱式循環(huán)引用

• 1: 前：

@implementation Person
{
    int _a;
    void (^_block)();
}
- (void)test
{
  void (^_block)() = ^{
        _a = 10;
    };
}

@end

• 2: 后：

struct __Person__test_block_impl_0 {
  struct __block_impl impl;
  struct __Person__test_block_desc_0* Desc;
  // 可以看到，block強(qiáng)引用了self
  Person *self;
  __Person__test_block_impl_0(void *fp, struct __Person__test_block_desc_0 *desc, Person *_self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
  Person *self = __cself->self; // bound by copy

        (*(int *)((char *)self + OBJC_IVAR_$_Person$_a)) = 10;
    }
static void __Person__test_block_copy_0(struct __Person__test_block_impl_0*dst, struct __Person__test_block_impl_0*src) {_Block_object_assign((void*)&dst->self, (void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __Person__test_block_dispose_0(struct __Person__test_block_impl_0*src) {_Block_object_dispose((void*)src->self, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __Person__test_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __Person__test_block_impl_0*, struct __Person__test_block_impl_0*);
  void (*dispose)(struct __Person__test_block_impl_0*);
} __Person__test_block_desc_0_DATA = { 0, sizeof(struct __Person__test_block_impl_0), __Person__test_block_copy_0, __Person__test_block_dispose_0};

static void _I_Person_test(Person * self, SEL _cmd) {
  void (*_block)() = (void (*)())&__Person__test_block_impl_0((void *)__Person__test_block_func_0, &__Person__test_block_desc_0_DATA, self, 570425344);
}

如果在編譯轉(zhuǎn)換前，將_a改成self.a，能很明顯地看出是產(chǎn)生了循環(huán)引用(self強(qiáng)引用block，block強(qiáng)引用self)。那么使用_a呢？經(jīng)過(guò)編譯轉(zhuǎn)換后，依然可以在__Person__test_block_impl_0看見(jiàn)self的身影。且在函數(shù)_I_Person_test中，傳入的參數(shù)也是self。通過(guò)以下語(yǔ)句，可以看出，不管是用什么形式訪問(wèn)實(shí)例變量，最終都會(huì)轉(zhuǎn)換成self+變量?jī)?nèi)存偏移的形式。所以在上面例子中使用_a也會(huì)造成循環(huán)引用。

static void __Person__test_block_func_0(struct __Person__test_block_impl_0 *__cself) {
  Person *self = __cself->self; // bound by copy
        // self＋實(shí)例變量a的偏移值
        (*(int *)((char *)self + OBJC_IVAR_$_Person$_a)) = 10;
    }

4: 不同類型block的復(fù)制

block的復(fù)制代碼在_Block_copy_internal函數(shù)中。

4.1 :棧block

棧block的復(fù)制不僅僅復(fù)制了其內(nèi)容，還添加了一些額外的東西

• 1: 往flags中并入了BLOCK_NEEDS_FREE（這個(gè)標(biāo)志表明block需要釋放，在release以及再次拷貝時(shí)會(huì)用到）
• 2: 如果有輔助copy函數(shù)BLOCK_HAS_COPY_DISPOSE, 那么就調(diào)用（這個(gè)輔助copy函數(shù)是用來(lái)拷貝block捕獲的變量）

...
struct Block_layout *result = malloc(aBlock->descriptor->size);
   if (!result) return (void *)0;
   memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
   // reset refcount
   result->flags &= ~(BLOCK_REFCOUNT_MASK);    // XXX not needed
   result->flags |= BLOCK_NEEDS_FREE | 1;
   result->isa = _NSConcreteMallocBlock;
   if (result->flags & BLOCK_HAS_COPY_DISPOSE) {
       //printf("calling block copy helper %p(%p, %p)...\n", aBlock->descriptor->copy, result, aBlock);
       (*aBlock->descriptor->copy)(result, aBlock); // do fixup
   }
   return result;
...

4.2 :堆block

如果block的flags中有BLOCK_NEEDS_FREE標(biāo)志（block從棧中拷貝到堆時(shí)添加的標(biāo)志），就執(zhí)行latching_incr_int操作，其功能就是讓block的引用計(jì)數(shù)加1。所以堆中block的拷貝只是單純地改變了引用計(jì)數(shù)

  if (aBlock->flags & BLOCK_NEEDS_FREE) {
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
  }

4.3 全局block

從以下代碼看出，對(duì)于全局block，函數(shù)沒(méi)有做任何操作，直接返回了傳入的block

 else if (aBlock->flags & BLOCK_IS_GLOBAL) {
        return aBlock;
    }

5: block輔助函數(shù)

block輔助copy與dispose處理函數(shù)，這里分析下這兩個(gè)函數(shù)的內(nèi)部實(shí)現(xiàn)。在捕獲變量為_(kāi)_block修飾的基本類型，或者為對(duì)象時(shí)，block才會(huì)有這兩個(gè)輔助函數(shù)。
block捕捉變量拷貝函數(shù)為_Block_object_assign。在調(diào)用復(fù)制block的函數(shù)_Block_copy_internal時(shí)，會(huì)根據(jù)block有無(wú)輔助函數(shù)來(lái)對(duì)捕捉變量拷貝函數(shù)_Block_object_assign進(jìn)行調(diào)用。而在_Block_object_assign函數(shù)中，也會(huì)判斷捕捉變量包裝而成的對(duì)象(Block_byref結(jié)構(gòu)體)是否有輔助函數(shù)，來(lái)進(jìn)行調(diào)用。

5.1 __block修飾的基本類型的輔助函數(shù)

編寫(xiě)以下代碼：

typedef void(^Block)();
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block int a;
        Block block = ^ {
            a;
        };
}

換成C++代碼后

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

struct __main_block_impl_0 {
  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) {
    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_a_0 *a = __cself->a; // bound by ref

            (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*/);}

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[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        __attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 0, sizeof(__Block_byref_a_0)};
;
        Block block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344));
    }
}

從上面代碼中，被__block修飾的a變量變?yōu)榱?code>__Block_byref_a_0類型，根據(jù)這個(gè)格式，從源碼中查看得到相似的定義：

struct Block_byref {
    void *isa;
    struct Block_byref *forwarding;
    int flags; /* refcount; */
    int size;
    void (*byref_keep)(struct Block_byref *dst, struct Block_byref *src);
    void (*byref_destroy)(struct Block_byref *);
    /* long shared[0]; */
};

// 做下對(duì)比
struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 int a;
};

// flags/_flags類型
enum {
        /* See function implementation for a more complete description of these fields and combinations */
        // 是一個(gè)對(duì)象
        BLOCK_FIELD_IS_OBJECT   =  3,  /* id, NSObject, __attribute__((NSObject)), block, ... */
        // 是一個(gè)block
        BLOCK_FIELD_IS_BLOCK    =  7,  /* a block variable */
        // 被__block修飾的變量
        BLOCK_FIELD_IS_BYREF    =  8,  /* the on stack structure holding the __block variable */
        // 被__weak修飾的變量，只能被輔助copy函數(shù)使用
        BLOCK_FIELD_IS_WEAK     = 16,  /* declared __weak, only used in byref copy helpers */
        // block輔助函數(shù)調(diào)用（告訴內(nèi)部實(shí)現(xiàn)不要進(jìn)行retain或者copy）
        BLOCK_BYREF_CALLER      = 128  /* called from __block (byref) copy/dispose support routines. */
    };

可以看出，__block將原來(lái)的基本類型包裝成了對(duì)象。因?yàn)橐陨蟽蓚€(gè)結(jié)構(gòu)體的前4個(gè)成員的類型都是一樣的，內(nèi)存空間排列一致，所以可以進(jìn)行以下操作：

// 轉(zhuǎn)換成C++代碼
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*/);}

// _Block_object_assign源碼
void _Block_object_assign(void *destAddr, const void *object, const int flags) {
...
    else if ((flags & BLOCK_FIELD_IS_BYREF) == BLOCK_FIELD_IS_BYREF)  {
        // copying a __block reference from the stack Block to the heap
        // flags will indicate if it holds a __weak reference and needs a special isa
        _Block_byref_assign_copy(destAddr, object, flags);
    }
...
}

// _Block_byref_assign_copy源碼
static void _Block_byref_assign_copy(void *dest, const void *arg, const int flags) {
    // 這里因?yàn)榍懊?個(gè)成員的內(nèi)存分布一樣，所以直接轉(zhuǎn)換后，使用Block_byref的成員變量名，能訪問(wèn)到__Block_byref_a_0的前面4個(gè)成員
    struct Block_byref **destp = (struct Block_byref **)dest;
    struct Block_byref *src = (struct Block_byref *)arg;
...
    else if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // 從main函數(shù)對(duì)__Block_byref_a_0的初始化，可以看到初始化時(shí)將flags賦值為0
        // 這里表示第一次拷貝，會(huì)進(jìn)行復(fù)制操作，并修改原來(lái)flags的值
        // static int _Byref_flag_initial_value = BLOCK_NEEDS_FREE | 2;
        // 可以看出，復(fù)制后，會(huì)并入BLOCK_NEEDS_FREE，后面的2是block的初始引用計(jì)數(shù)
        ...
        copy->flags = src->flags | _Byref_flag_initial_value;
        ...
    }
    // 已經(jīng)拷貝到堆了，只增加引用計(jì)數(shù)
    else if ((src->forwarding->flags & BLOCK_NEEDS_FREE) == BLOCK_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    // 普通的賦值，里面最底層就*destptr = value;這句表達(dá)式
    _Block_assign(src->forwarding, (void **)destp);
}

主要操作都在代碼注釋中了，總體來(lái)說(shuō)，__block修飾的基本類型會(huì)被包裝為對(duì)象，并且只在最初block拷貝時(shí)復(fù)制一次，后面的拷貝只會(huì)增加這個(gè)捕獲變量的引用計(jì)數(shù)。

5.2 對(duì)象的輔助函數(shù)

• 1: 沒(méi)有__block修飾

typedef void(^Block)();
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSObject *a = [[NSObject alloc] init];
        Block block = ^ {
            a;
        };
    }
    return 0;
}

首先，在沒(méi)有__block修飾時(shí)，對(duì)象編譯轉(zhuǎn)換的結(jié)果如下，刪除了一些變化不大的代碼：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  NSObject *a = __cself->a; // bound by copy
            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, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, 3/*BLOCK_FIELD_IS_OBJECT*/);}

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),

對(duì)象在沒(méi)有__block修飾時(shí)，并沒(méi)有產(chǎn)生__Block_byref_a_0結(jié)構(gòu)體，只是將標(biāo)志位修改為BLOCK_FIELD_IS_OBJECT。而在_Block_object_assign中對(duì)應(yīng)的判斷分支代碼如下：

else if ((flags & BLOCK_FIELD_IS_OBJECT) == BLOCK_FIELD_IS_OBJECT) {
    _Block_retain_object(object);
    _Block_assign((void *)object, destAddr);
}

可以看到，block復(fù)制時(shí)，會(huì)retain捕捉對(duì)象，以增加其引用計(jì)數(shù)。

• 2: 有__block修飾

typedef void(^Block)();
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        __block NSObject *a = [[NSObject alloc] init];
        Block block = ^ {
            a;
        };
    }
    return 0;
}

在這種情況下，編譯轉(zhuǎn)換的部分結(jié)果如下：

struct __Block_byref_a_0 {
  void *__isa;
__Block_byref_a_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSObject *a;
};
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*)0,(__Block_byref_a_0 *)&a, 33554432, sizeof(__Block_byref_a_0), __Block_byref_id_object_copy_131, __Block_byref_id_object_dispose_131,....};
Block block = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, 570425344);
}

// 以下的40表示__Block_byref_a_0對(duì)象a的位移（4個(gè)指針(32字節(jié))＋2個(gè)int變量(8字節(jié))＝40字節(jié)）
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

可以看到，對(duì)于對(duì)象，__Block_byref_a_0另外增加了兩個(gè)輔助函數(shù)__Block_byref_id_object_copy、__Block_byref_id_object_dispose,以實(shí)現(xiàn)對(duì)對(duì)象內(nèi)存的管理。其中兩者的最后一個(gè)參數(shù)131表示BLOCK_BYREF_CALLER|BLOCK_FIELD_IS_OBJECT，BLOCK_BYREF_CALLER表示在內(nèi)部實(shí)現(xiàn)中不對(duì)a對(duì)象進(jìn)行retain或copy；以下為相關(guān)源碼：

if ((flags & BLOCK_BYREF_CALLER) == BLOCK_BYREF_CALLER) {
    ...
    else {
        // do *not* retain or *copy* __block variables whatever they are
        _Block_assign((void *)object, destAddr);
    }
}

_Block_byref_assign_copy函數(shù)的以下代碼會(huì)對(duì)上面的輔助函數(shù)（__Block_byref_id_object_copy_131）進(jìn)行調(diào)用；570425344表示BLOCK_HAS_COPY_DISPOSE|BLOCK_HAS_DESCRIPTOR，所以會(huì)執(zhí)行以下相關(guān)源碼：

if (src->flags & BLOCK_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
    copy->byref_keep = src->byref_keep;
    copy->byref_destroy = src->byref_destroy;
    (*src->byref_keep)(copy, src);
}

6: ARC中block的工作

蘋(píng)果文檔提及，在ARC模式下，在棧間傳遞block時(shí)，不需要手動(dòng)copy棧中的block，即可讓block正常工作。主要原因是ARC對(duì)棧中的block自動(dòng)執(zhí)行了copy，將_NSConcreteStackBlock類型的block轉(zhuǎn)換成了_NSConcreteMallocBlock的block。

6.1 : block試驗(yàn)

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        int i = 10;
        void (^block)() = ^{i;};

        __weak void (^weakBlock)() = ^{i;};

        void (^stackBlock)() = ^{};

        // ARC情況下

        // 創(chuàng)建時(shí)，都會(huì)在棧中
        // <__NSStackBlock__: 0x7fff5fbff730>
        NSLog(@"%@", ^{i;});

        // 因?yàn)閎lock為strong類型，且捕獲了外部變量，所以賦值時(shí)，自動(dòng)進(jìn)行了copy
        // <__NSMallocBlock__: 0x100206920>
        NSLog(@"%@", block);

        // 如果是weak類型的block，依然不會(huì)自動(dòng)進(jìn)行copy
        // <__NSStackBlock__: 0x7fff5fbff728>
        NSLog(@"%@", weakBlock);

        // 如果block是strong類型，并且沒(méi)有捕獲外部變量，那么就會(huì)轉(zhuǎn)換成__NSGlobalBlock__
        // <__NSGlobalBlock__: 0x100001110>
        NSLog(@"%@", stackBlock);

        // 在非ARC情況下，產(chǎn)生以下輸出
        // <__NSStackBlock__: 0x7fff5fbff6d0>
        // <__NSStackBlock__: 0x7fff5fbff730>
        // <__NSStackBlock__: 0x7fff5fbff700>
        // <__NSGlobalBlock__: 0x1000010d0>
    }
    return 0;
}

可以看出，ARC對(duì)類型為strong且捕獲了外部變量的block進(jìn)行了copy。并且當(dāng)block類型為strong，但是創(chuàng)建時(shí)沒(méi)有捕獲外部變量，block最終會(huì)變成__NSGlobalBlock__類型（這里可能因?yàn)閎lock中的代碼沒(méi)有捕獲外部變量，所以不需要在棧中開(kāi)辟變量，也就是說(shuō)，在編譯時(shí)，這個(gè)block的所有內(nèi)容已經(jīng)在代碼段中生成了，所以就把block的類型轉(zhuǎn)換為全局類型）

6.2: block作為參數(shù)傳遞

再來(lái)看下使用在棧中的block需要注意的情況：

NSMutableArray *arrayM;
void myBlock()
{
    int a = 5;
    Block block = ^ {
        NSLog(@"%d", a);
    };

    [arrayM addObject:block];
    NSLog(@"%@", block);
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        arrayM = @[].mutableCopy;

        myBlock();

        Block block = [arrayM firstObject];
        // 非ARC這里崩潰
        block();
 }

// ARC情況下輸出
// <__NSMallocBlock__: 0x100214480>

// 非ARC情況下輸出
// <__NSStackBlock__: 0x7fff5fbff738>
// 崩潰，野指針錯(cuò)誤

可以看到，ARC情況下因?yàn)樽詣?dòng)執(zhí)行了copy，所以返回類型為__NSMallocBlock__，在函數(shù)結(jié)束后依然可以訪問(wèn)；而非ARC情況下，需要我們手動(dòng)調(diào)用[block copy]來(lái)將block拷貝到堆中，否則因?yàn)闂Ｖ械腷lock生命周期和函數(shù)中的棧生命周期關(guān)聯(lián)，當(dāng)函數(shù)退出后，相應(yīng)的堆被銷毀，block也就不存在了。

如果把block的以下代碼刪除：

NSLog(@"%d", a);

那么block就會(huì)變成全局類型，在main中訪問(wèn)也不會(huì)出崩潰。

6.3: block作為返回值

在非ARC情況下，如果返回值是block，則一般這樣操作：

return [[block copy] autorelease];

對(duì)于外部要使用的block，更趨向于把它拷貝到堆中，使其脫離棧生命周期的約束。

6.4: block屬性

這里還有一點(diǎn)關(guān)于block類型的ARC屬性。上文也說(shuō)明了，ARC會(huì)自動(dòng)幫strong類型且捕獲外部變量的block進(jìn)行copy，所以在定義block類型的屬性時(shí)也可以使用strong，不一定使用copy。也就是以下代碼：

/** 假如有棧block賦給以下兩個(gè)屬性 **/

// 這里因?yàn)锳RC，當(dāng)棧block中會(huì)捕獲外部變量時(shí)，這個(gè)block會(huì)被copy進(jìn)堆中
// 如果沒(méi)有捕獲外部變量，這個(gè)block會(huì)變?yōu)槿诸愋?// 不管怎么樣，它都脫離了棧生命周期的約束

@property (strong, nonatomic) Block *strongBlock;

// 這里都會(huì)被copy進(jìn)堆中
@property (copy, nonatomic) Block *copyBlock;

http://blog.devtang.com/2013/07/28/a-look-inside-blocks/
http://blog.csdn.net/jasonblog/article/details/7756763
http://www.galloway.me.uk/2013/05/a-look-inside-blocks-episode-3-block-copy/
http://llvm.org/svn/llvm-project/compiler-rt/trunk/lib/BlocksRuntime/runtime.c
http://llvm.org/svn/llvm-project/compiler-rt/trunk/lib/BlocksRuntime/Block_private.h
http://clang.llvm.org/docs/Block-ABI-Apple.html
https://github.com/EmbeddedSources/BlockRuntime
http://www.itdecent.cn/p/51d04b7639f1

1: 一篇文章看懂iOS代碼塊Block

2: OC中， block（塊）的本質(zhì)是什么？

3: Objective-C語(yǔ)法之代碼塊(block)的使用

4： Objective-C中的Block

5: Block技巧與底層解析

6: 黑幕背后的__block修飾符

7: 你真的理解__block修飾符的原理么？

8: iOS-Block的使用你看我啊