本文Demo傳送門：BlockTestApp

【摘要】這篇文章，首先在第1節中介紹Block的定義，以及與C里面函數的對比。然后，第2節介紹實際開發中經常會用到的Block語法形式，以供讀者日后查閱。只知道怎么用卻不知什么時候用？所以隨后的第3節將介紹Block的應用場景。然而，用Block不當導致了Crash？所以，第4節有必要了解Block捕獲變量的特性，以及循環引用的解決。另外，千萬不要懶，一碰到Block就weak，要區分哪些不會引起循環引用。然而，如果對Block的內存機制不熟悉，也會導致Crash，所以第5節會介紹Block的內存機制。學到這里已經夠用了。然而，你卻想進一步了解Block的實現機制？第6節將簡單介紹下clang的編譯與Block的實現及其原理。

1. 前言

Block：帶有自動變量（局部變量）的匿名函數。它是C語言的擴充功能。之所以是拓展，是因為C語言不允許存在這樣匿名函數。

1.1 匿名函數

匿名函數是指不帶函數名稱函數。C語言中，函數是怎樣的呢？類似這樣：

int func(int count);

調用的時候：

int result = func(10);

func就是它的函數名。也可以通過指針調用函數，看起來沒用到函數名：

int result = (*funcptr)(10);

實際，在賦值給函數指針時，必須通過函數的名稱才能獲得該函數的地址。完整的步驟應該是：

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

而通過Block，就能夠使用匿名函數，即不帶函數名稱的函數。

1.2 帶有自動變量

關于“帶有自動變量（局部變量）”的含義，這是因為Block擁有捕獲外部變量的功能。在Block中訪問一個外部的局部變量，Block會持用它的臨時狀態，自動捕獲變量值，外部局部變量的變化不會影響它的的狀態。

捕獲外部變量，看一個經典block面試題：

int val = 10; 
void (^blk)(void) = ^{
    printf("val=%d\n",val);
}; 
val = 2; 
blk(); 

上面這段代碼，輸出值是：val = 10，而不是2。

block 在實現時就會對它引用到的它所在方法中定義的棧變量進行一次只讀拷貝，然后在 block 塊內使用該只讀拷貝；換句話說block截獲自動變量的瞬時值；或者block捕獲的是自動變量的副本。

由于block捕獲了自動變量的瞬時值，所以在執行block語法后，即使改寫block中使用的自動變量的值也不會影響block執行時自動變量的值。

所以，上面的面試題的結果是10，不是2。

解決block不能修改自動變量的值，這一問題的另外一個辦法是使用__block修飾符。

__block int val = 10;  
void (^blk)(void) = ^{printf("val=%d\n",val);};  
val = 2;  
blk(); 

上面的代碼，跟第一個代碼段相比只是多了一個__block修飾符。但是輸出結果確是2。

2. Block語法大全

約定：用法中的符號含義列舉如下：

• return_type 表示返回的對象/關鍵字等(可以是void，并省略)
• blockName 表示block的名稱
• var_type 表示參數的類型(可以是void，并省略)
• varName 表示參數名稱

2.1 Block聲明及定義語法，及其變形

(1) 標準聲明與定義

return_type (^blockName)(var_type) = ^return_type (var_type varName) {
    // ...
};
blockName(var);

(2) 當返回類型為void

void (^blockName)(var_type) = ^void (var_type varName) {
    // ...
};
blockName(var);

可省略寫成

void (^blockName)(var_type) = ^(var_type varName) {
    // ...
};
blockName(var);

(3) 當參數類型為void

return_type (^blockName)(void) = ^return_type (void) {
    // ...
};
blockName();

可省略寫成

return_type (^blockName)(void) = ^return_type {
    // ...
};
blockName();

(4) 當返回類型和參數類型都為void

void (^blockName)(void) = ^void (void) {
    // ...
};
blockName();

可省略寫成

void (^blockName)(void) = ^{
    // ...
};
blockName();

(5) 匿名Block

Block實現時，等號右邊就是一個匿名Block，它沒有blockName，稱之為匿名Block：

^return_type (var_type varName)
{
    //...
};

2.2 typedef簡化Block的聲明

利用typedef簡化Block的聲明：

• 聲明

typedef return_type (^BlockTypeName)(var_type);

• 例子1：作屬性

//聲明
typedef void(^ClickBlock)(NSInteger index);
//block屬性
@property (nonatomic, copy) ClickBlock imageClickBlock;

• 例子2：作方法參數

//聲明
typedef void (^handleBlock)();
//block作參數
- (void)requestForRefuseOrAccept:(MessageBtnType)msgBtnType messageModel:(MessageModel *)msgModel handle:(handleBlock)handle{
  ...

2.3 Block的常見用法

2.3.1 局部位置聲明一個Block型的變量

• 位置

return_type (^blockName)(var_type) = ^return_type (var_type varName) {
    // ...
};
blockName(var);

• 例子

void (^globalBlockInMemory)(int number) = ^(int number){
     printf("%d \n",number);
};
globalBlockInMemory(90);

2.3.2 @interface位置聲明一個Block型的屬性

• 位置

@property(nonatomic, copy)return_type (^blockName) (var_type);

• 例子

//按鈕點擊Block
@property (nonatomic, copy) void (^btnClickedBlock)(UIButton *sender);

2.3.3 在定義方法時，聲明Block型的形參

• 用法

- (void)yourMethod:(return_type (^)(var_type))blockName;

• 例子

UIView+AddClickedEvent.h

- (void)addClickedBlock:(void(^)(id obj))clickedAction;

2.3.4 在調用如上方法時，Block作實參

• 例子

UIView+AddClickedEvent.m

- (void)addClickedBlock:(void(^)(id obj))clickedAction{
    self.clickedAction = clickedAction;
    // :先判斷當前是否有交互事件，如果沒有的話。。。所有gesture的交互事件都會被添加進gestureRecognizers中
    if (![self gestureRecognizers]) {
        self.userInteractionEnabled = YES;
        // :添加單擊事件
        UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(tap)];
        [self addGestureRecognizer:tap];
    }
}

- (void)tap{
    if (self.clickedAction) {
        self.clickedAction(self);
    }
}

2.4 Block的少見用法

2.4.1 Block的內聯用法

這種形式并不常用，匿名Block聲明后立即被調用：

^return_type (var_type varName)
{
    //...
}(var);

2.4.2 Block的遞歸調用

Block內部調用自身，遞歸調用是很多算法基礎，特別是在無法提前預知循環終止條件的情況下。注意：由于Block內部引用了自身，這里必須使用__block避免循環引用問題。

__block return_type (^blockName)(var_type) = [^return_type (var_type varName)
{
    if (returnCondition)
    {
        blockName = nil;
        return;
    }
    // ...
    // 【遞歸調用】
    blockName(varName);
} copy];

【初次調用】
blockName(varValue);

2.4.3 Block作為返回值

方法的返回值是一個Block，可用于一些“工廠模式”的方法中：

• 用法：

- (return_type(^)(var_type))methodName
{
    return ^return_type(var_type param) {
        // ...
    };
}

• 例子：Masonry框架里面的??

- (MASConstraint * (^)(id))equalTo {
    return ^id(id attribute) {
        return self.equalToWithRelation(attribute, NSLayoutRelationEqual);
    };
}

- (MASConstraint * (^)(id, NSLayoutRelation))equalToWithRelation {
    return ^id(id attribute, NSLayoutRelation relation) {
        if ([attribute isKindOfClass:NSArray.class]) {
            NSAssert(!self.hasLayoutRelation, @"Redefinition of constraint relation");
            NSMutableArray *children = NSMutableArray.new;
            for (id attr in attribute) {
                MASViewConstraint *viewConstraint = [self copy];
                viewConstraint.secondViewAttribute = attr;
                [children addObject:viewConstraint];
            }
            MASCompositeConstraint *compositeConstraint = [[MASCompositeConstraint alloc] initWithChildren:children];
            compositeConstraint.delegate = self.delegate;
            [self.delegate constraint:self shouldBeReplacedWithConstraint:compositeConstraint];
            return compositeConstraint;
        } else {
            NSAssert(!self.hasLayoutRelation || self.layoutRelation == relation && [attribute isKindOfClass:NSValue.class], @"Redefinition of constraint relation");
            self.layoutRelation = relation;
            self.secondViewAttribute = attribute;
            return self;
        }
    };
}

3. Block應用場景

3.1 響應事件

情景：UIViewContoller有個UITableView并是它的代理，通過UITableView加載CellView。現在需要監聽CellView中的某個按鈕（可以通過tag值區分），并作出響應。

如上面 2.3.2節在CellView.h中@interface位置聲明一個Block型的屬性，為了設置激活事件調用Block，接著我們在CellView.m中作如下設置：

// 激活事件
#pragma mark - 按鈕點擊事件
- (IBAction)btnClickedAction:(UIButton *)sender {
    if (self.btnClickedBlock) {
        self.btnClickedBlock(sender);
    }
}

隨后，在ViewController.m的適當位置（- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{...代理方法）中通過setter方法設置CellView的Block屬性。Block寫著當按鈕被點擊后要執行的邏輯。

// 響應事件
cell.btnClickedBlock = ^(UIButton *sender) {
    //標記消息已讀
    [weakSelf requestToReadedMessageWithTag:sender.tag];
    //刷新當前cell
    [tableView reloadRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationNone];
};

其實，即使Block不傳遞任何參數，也可以傳遞事件的。但這種情況，無法區分事件的激活方（cell里面的哪一個按鈕？）。即：

//按鈕點擊Block
@property (nonatomic, copy) void (^btnClickedBlock)(void);

// 激活事件
#pragma mark - 按鈕點擊事件
- (IBAction)btnClickedAction:(UIButton *)sender {
    if (self.btnClickedBlock) {
        self.btnClickedBlock();
    }
}

// 響應事件
cell.btnClickedBlock = ^{
    //標記消息已讀
    [weakSelf requestToReadedMessageWithTag:nil];
    //刷新當前cell
    [tableView reloadRowsAtIndexPaths:@[indexPath] withRowAnimation:UITableViewRowAnimationNone];
};

3.2 傳遞數據

上面的響應事件，其實也是傳遞數據，只是它傳遞的對象是UIButton。如下所示，SubTableView是VC的一個屬性和子視圖。

• 傳遞數值

SubTableView.h

@property (strong, nonatomic) void (^handleDidSelectedItem)(int indexPath);

SubTableView.m

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    [tableView deselectRowAtIndexPath:indexPath animated:YES];
    _handleDidSelectedItem ? _handleDidSelectedItem(indexPath) : NULL;
}

VC.m

[_subView setHandleDidSelectedItem:^(int indexPath) {
        [weakself handleLabelDidSearchTableSelectedItem:indexPath];
    }];

- (void)handleLabelDidSearchTableSelectedItem:(int )indexPath {
    if (indexPath==0) {
        [[UIApplication sharedApplication] openURL:[NSURL URLWithString:[NSString stringWithFormat:@"telprompt:%@", self.searchNullView.telLabel.text]]];
    }else if (indexPath==1){
        [self.navigationController popViewControllerAnimated:YES];
    }
}

• 傳遞對象

例如HYBNetworking網絡框架中請求成功時傳遞接口返回數據對象的Block:

[HYBNetworking postWithUrl:kSearchProblem refreshCache:NO params:params success:^(id response) {
        
        typeof(weakSelf) strongSelf = weakSelf;
//        [KVNProgress dismiss];
        NSString *stringData = [response mj_JSONString];
        stringData = [DES3Util decrypt:stringData];
        NSLog(@"stirngData: %@", stringData);
       ...
}

3.3 鏈式語法

鏈式編程思想：核心思想為將block作為方法的返回值，且返回值的類型為調用者本身，并將該方法以setter的形式返回，這樣就可以實現了連續調用，即為鏈式編程。

Masonry的一個典型的鏈式編程用法如下：

[self.containerView addSubview:self.bannerView];
[self.bannerView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.leading.equalTo(self.containerView.mas_leading);
    make.top.equalTo(self.containerView.mas_top);
    make.trailing.equalTo(self.containerView.mas_trailing);
    make.height.equalTo(@(kViewWidth(131.0)));
}];

現在，簡單使用鏈式編程思想實現一個簡單計算器的功能：

3.3.1 在CaculateMaker.h文件中聲明一個方法add：

• CaculateMaker.h

//  CaculateMaker.h
//  ChainBlockTestApp

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>

@interface CaculateMaker : NSObject

@property (nonatomic, assign) CGFloat result;

- (CaculateMaker *(^)(CGFloat num))add;

@end

3.3.2 在CaculateMaker.m文件中實現add方法：

• CaculateMaker.m

//  CaculateMaker.m
//  ChainBlockTestApp


#import "CaculateMaker.h"

@implementation CaculateMaker

- (CaculateMaker *(^)(CGFloat num))add;{
    return ^CaculateMaker *(CGFloat num){
        _result += num;
        return self;
    };
}

@end

3.3.3 在viewController里面導入CaculateMaker.h文件，然后調用add方法就完成了鏈式語法：

• ViewController.m

CaculateMaker *maker = [[CaculateMaker alloc] init];
maker.add(20).add(30);

4. Block使用注意

4.1 截獲自動變量與__block說明符

前面講過block所在函數中的，捕獲自動變量。但是不能修改它，不然就是“編譯錯誤”。但是可以改變全局變量、靜態變量、全局靜態變量。其實這兩個特點不難理解：

• 不能修改自動變量的值是因為：block捕獲的是自動變量的const值，名字一樣，不能修改

• 可以修改靜態變量的值：靜態變量屬于類的，不是某一個變量。由于block內部不用調用self指針。所以block可以調用。

解決block不能修改自動變量的值，這一問題的另外一個辦法是使用__block修飾符。

4.2 截獲對象

對于捕獲ObjC對象，不同于基本類型；Block會引起對象的引用計數變化。

@interface MyClass : NSObject {  
    NSObject* _instanceObj;  
}  
@end  
  
@implementation MyClass  
  
NSObject* __globalObj = nil;  
  
- (id) init {  
    if (self = [super init]) {  
        _instanceObj = [[NSObject alloc] init];  
    }  
    return self;  
}  
  
- (void) test {  
    static NSObject* __staticObj = nil;  
    __globalObj = [[NSObject alloc] init];  
    __staticObj = [[NSObject alloc] init];  
  
    NSObject* localObj = [[NSObject alloc] init];  
    __block NSObject* blockObj = [[NSObject alloc] init];  
  
    typedef void (^MyBlock)(void) ;  
    MyBlock aBlock = ^{  
        NSLog(@"%@", __globalObj);  
        NSLog(@"%@", __staticObj);  
        NSLog(@"%@", _instanceObj);  
        NSLog(@"%@", localObj);  
        NSLog(@"%@", blockObj);  
    };  
    aBlock = [[aBlock copy] autorelease];  
    aBlock();  
  
    NSLog(@"%d", [__globalObj retainCount]);  
    NSLog(@"%d", [__staticObj retainCount]);  
    NSLog(@"%d", [_instanceObj retainCount]);  
    NSLog(@"%d", [localObj retainCount]);  
    NSLog(@"%d", [blockObj retainCount]);  
}  
@end  
  
int main(int argc, charchar *argv[]) {  
    @autoreleasepool {  
        MyClass* obj = [[[MyClass alloc] init] autorelease];  
        [obj test];  
        return 0;  
    }  
}  

執行結果為1 1 1 2 1。

__globalObj和__staticObj在內存中的位置是確定的，所以Block copy時不會retain對象。

_instanceObj在Block copy時也沒有直接retain _instanceObj對象本身，但會retain self。所以在Block中可以直接讀寫_instanceObj變量。
localObj在Block copy時，系統自動retain對象，增加其引用計數。
blockObj在Block copy時也不會retain。

4.3 Block引起的循環引用

一般來說我們總會在設置Block之后，在合適的時間回調Block，而不希望回調Block的時候Block已經被釋放了，所以我們需要對Block進行copy，copy到堆中，以便后用。

Block可能會導致循環引用問題，因為block在拷貝到堆上的時候，會retain其引用的外部變量，那么如果block中如果引用了他的宿主對象，那很有可能引起循環引用，如：

• TestCycleRetain

- (void) dealloc {
    NSLog(@"no cycle retain");
} 

- (id) init {
    self = [super init];
    if (self) {

        #if TestCycleRetainCase1
        //會循環引用
        self.myblock = ^{
            [self doSomething];
        };
  
        #elif TestCycleRetainCase2
        //會循環引用
        __block TestCycleRetain * weakSelf = self;
        self.myblock = ^{
            [weakSelf doSomething];
        };

        #elif TestCycleRetainCase3
        //不會循環引用
        __weak TestCycleRetain * weakSelf = self;
        self.myblock = ^{
            [weakSelf doSomething];
        };

        #elif TestCycleRetainCase4
        //不會循環引用
        __unsafe_unretained TestCycleRetain * weakSelf = self;
        self.myblock = ^{
            [weakSelf doSomething];
        };

        #endif NSLog(@"myblock is %@", self.myblock);
    }
    return self;
} 

- (void) doSomething {
    NSLog(@"do Something");
}

• main

int main(int argc, char * argv[]) {
    @autoreleasepool {
        TestCycleRetain * obj = [[TestCycleRetain alloc] init];
        obj = nil;
        return 0;
    }
}

• MRC情況下，用__block可以消除循環引用。
• ARC情況下，必須用弱引用才可以解決循環引用問題，iOS 5之后可以直接使用__weak，之前則只能使用__unsafe_unretained了，__unsafe_unretained缺點是指針釋放后自己不會置

在上述使用 block中，雖說使用__weak，但是此處會有一個隱患，你不知道 self 什么時候會被釋放，為了保證在block內不會被釋放，我們添加__strong。更多的時候需要配合strongSelf使用，如下：

__weak __typeof(self) weakSelf = self; 
self.testBlock =  ^{
       __strong __typeof(weakSelf) strongSelf = weakSelf;
       [strongSelf test]; 
});

4.4 實用宏定義：避免Block引起循環引用

• 第一步

在工程的TestAPP-Prefix.pch的文件中直接（不推薦）或在其導入的頭文件中間接寫入以下宏定義：

//----------------------強弱引用----------------------------
#ifndef weakify
#if DEBUG
#if __has_feature(objc_arc)
#define weakify(object) autoreleasepool{} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) autoreleasepool{} __block __typeof__(object) block##_##object = object;
#endif
#else
#if __has_feature(objc_arc)
#define weakify(object) try{} @finally{} {} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) try{} @finally{} {} __block __typeof__(object) block##_##object = object;
#endif
#endif
#endif

#ifndef strongify
#if DEBUG
#if __has_feature(objc_arc)
#define strongify(object) autoreleasepool{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) autoreleasepool{} __typeof__(object) object = block##_##object;
#endif
#else
#if __has_feature(objc_arc)
#define strongify(object) try{} @finally{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) try{} @finally{} __typeof__(object) object = block##_##object;
#endif
#endif
#endif

• 第二步

在設置Block體的時候，像如下這樣使用即可。

@weakify(self);
[footerView setClickFooterBlock:^{
        @strongify(self);
        [self handleClickFooterActionWithSectionTag:section];
}];

4.5 所有的Block里面的self必須要weak一下？

很顯然答案不都是，有些情況下是可以直接使用self的，比如調用系統的方法：

[UIView animateWithDuration:0.5 animations:^{
        NSLog(@"%@", self);
    }];

因為這個block存在于靜態方法中，雖然block對self強引用著，但是self卻不持有這個靜態方法，所以完全可以在block內部使用self。

另外，來看一個Masonry代碼布局的例子，這里面的self會不會造成循環引用呢？

[self.headView mas_makeConstraints:^(MASConstraintMaker *make) {
    make.centerY.equalTo(self.otherView.mas_centerY);
}];

并不是 block 就一定會造成循環引用，是不是循環引用要看是不是相互持有強引用。block 里用到了 self，那 block 會保持一個 self 的引用，但是 self 并沒有直接或者間接持有 block，所以不會造成循環引用。可以看一下Masonry的源代碼：

• View+MASAdditions.m

- (NSArray *)mas_makeConstraints:(void(^)(MASConstraintMaker *))block {
    self.translatesAutoresizingMaskIntoConstraints = NO;
    MASConstraintMaker *constraintMaker = [[MASConstraintMaker alloc] initWithView:self];
    block(constraintMaker);
    return [constraintMaker install];
}

• MASConstraintMaker.m

- (id)initWithView:(MAS_VIEW *)view {
    self = [super init];
    if (!self) return nil;
    
    self.view = view;
    self.constraints = NSMutableArray.new;
    
    return self;
}

持有鏈是這樣的，并沒有形成引用循環:

self ->self.headView ··· MASConstraintMaker構造block->self

注意觀察，這個作為方法參數的Block體并沒有被任何方持有。因此，我們放心在Masonry中使用self.xxx 不會循環引用的。而且這個block里面用weakSelf還有可能會出問題，因為mas_qeual如果得到一個nil參數的話應該會導致程序崩潰。

因為UIView未強持有block，所以這個block只是個棧block，而且構不成循環引用的條件。棧block有個特性就是它執行完畢之后就出棧，出棧了就會被釋放掉。看mas_makexxx的方法實現會發現這個block很快就被調用了，完事兒就出棧銷毀，構不成循環引用，所以可以直接放心的使self。另外，這個與網絡請求里面使用self道理是一樣的。

5. Block與內存管理

根據Block在內存中的位置分為三種類型：

• NSGlobalBlock是位于全局區的block，它是設置在程序的數據區域（.data區）中。

• NSStackBlock是位于棧區，超出變量作用域，棧上的Block以及 __block變量都被銷毀。

• NSMallocBlock是位于堆區，在變量作用域結束時不受影響。

注意：在 ARC 開啟的情況下，將只會有 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 類型的 block。

正如它們名字顯示得一樣，表明了block的三種存儲方式：棧、全局、堆。獲取block對象中的isa的值，可以得到上面其中一個，下面開始說明哪種block存儲在棧、堆、全局。

5.1 位于全局區：GlobalBlock

生成在全局區block有兩種情況：

• 定義全局變量的地方有block語法時

void(^block)(void) = ^ { NSLog(@"Global Block");};
int main() {
 
}

• block語法的表達式中沒有使用應截獲的自動變量時

int(^block)(int count) = ^(int count) {
        return count;
    };
 block(2);

雖然，這個block在循環內，但是blk的地址總是不變的。說明這個block在全局段。注：針對沒有捕獲自動變量的block來說，雖然用clang的rewrite-objc轉化后的代碼中仍顯示_NSConcretStackBlock，但是實際上不是這樣的。

5.2 位于棧內存：StackBlock

這種情況，在非ARC下是無法編譯的，在ARC下可以編譯。

• block語法的表達式中使用截獲的自動變量時

NSInteger i = 10; 
block = ^{ 
     NSLog(@"%ld", i); 
};
block;

設置在棧上的block，如果其作用域結束，該block就被銷毀。同樣的，由于__block變量也配置在棧上，如果其作用域結束，則該__block變量也會被銷毀。

另外，例如

typedef void (^block_t)() ;  

-(block_t)returnBlock{  
    __block int add=10;  
    return ^{
        printf("add=%d\n",++add);
    };  
}  

5.3 位于堆內存：MallocBlock

堆中的block無法直接創建，其需要由_NSConcreteStackBlock類型的block拷貝而來(也就是說block需要執行copy之后才能存放到堆中)。由于block的拷貝最終都會調用_Block_copy_internal函數。

void(^block)(void);

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

       __block NSInteger i = 10;
       block = [^{
           ++i;
       } copy];
       ++i; 
       block();
       NSLog(@"%ld", i);
   }
   return 0;
}

我們對這個生成在棧上的block執行了copy操作，Block和__block變量均從棧復制到堆上。上面的代碼，有跟沒有copy，在非ARC和ARC下一個是stack一個是Malloc。這是因為ARC下默認為Malloc（即使如此，ARC下還是有一些例外，下面會講）。

block在ARC和非ARC下有巨大差別。多數情況下，ARC下會默認把棧block被會直接拷貝生成到堆上。那么，什么時候棧上的Block會復制到堆上呢？

• 調用Block的copy實例方法時
• Block作為函數返回值返回時
• 將Block賦值給附有__strong修飾符id類型的類或Block類型成員變量時
• 將方法名中含有usingBlock的Cocoa框架方法或GCD的API中傳遞Block時

block在ARC和非ARC下的巨大差別

• 在 ARC 中，捕獲外部了變量的 block 的類會是 NSMallocBlock 或者 NSStackBlock，如果 block 被賦值給了某個變量，在這個過程中會執行 _Block_copy 將原有的 NSStackBlock 變成 NSMallocBlock；但是如果 block 沒有被賦值給某個變量，那它的類型就是 NSStackBlock；沒有捕獲外部變量的 block 的類會是 NSGlobalBlock 即不在堆上，也不在棧上，它類似 C 語言函數一樣會在代碼段中。

• 在非 ARC 中，捕獲了外部變量的 block 的類會是 NSStackBlock，放置在棧上，沒有捕獲外部變量的 block 時與 ARC 環境下情況相同。

例如

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self testBlockForHeapOfARC];
}
-(void)testBlockForHeapOfARC{
    int val =10;
    typedef void (^blk_t)(void);
    blk_t block = ^{
        NSLog(@"blk0:%d",val);
    };
    block();
}

image.png

即使如此，ARC下還是有一些例外：

例外

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self testBlockForHeap0];
}

#pragma mark - testBlockForHeap0 - crash
-(NSArray *)getBlockArray0{
    int val =10;
    return [NSArray arrayWithObjects:
            ^{NSLog(@"blk0:%d",val);},
            ^{NSLog(@"blk1:%d",val);},nil];
}


-(void)testBlockForHeap0{
    
    NSArray *tempArr = [self getBlockArray0];
    NSMutableArray *obj = [tempArr mutableCopy];
    typedef void (^blk_t)(void);
    blk_t block = (blk_t){[obj objectAtIndex:0]};
    block();
}

這段代碼在最后一行blk()會異常，因為數組中的block是棧上的。因為val是棧上的。解決辦法就是調用copy方法。這種場景，ARC也不會為你添加copy，因為ARC不確定，采取了保守的措施：不添加copy。所以ARC下也是會異常退出。

image.png

例外的改進1

調用block 的copy函數，將block拷貝到堆上:

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self testBlockForHeap1];
}

-(void)testBlockForHeap1{
    
    NSArray *tempArr = [self getBlockArray1];
    NSMutableArray *obj = [tempArr mutableCopy];
    typedef void (^blk_t)(void);
    blk_t block = (blk_t){[obj objectAtIndex:0]};
    block();
}

-(NSArray *)getBlockArray1{
    int val =10;
    return [NSArray arrayWithObjects:
            [^{NSLog(@"blk0:%d",val);} copy],
            [^{NSLog(@"blk1:%d",val);} copy],nil];
}

打個斷點可見，該Block的類型：

image.png

例外的改進2

例如下面代碼中，在addBlockToArray方法中的block還是_NSConcreteStackBlock類型的，在testBlockForHeap2方法中就被復制到了堆中，成為_NSConcreteMallocBlock類型的block：

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    [self testBlockForHeap2];
}

- (void)addBlockToArray:(NSMutableArray *)array {

    int val =10;
    [array addObjectsFromArray:@[
         ^{NSLog(@"blk0:%d",val);},
         ^{NSLog(@"blk1:%d",val);}]];
}

- (void)testBlockForHeap2{

    NSMutableArray *array = [NSMutableArray array];
    [self addBlockToArray:array];
    typedef void (^blk_t)(void);
    blk_t block = (blk_t){[array objectAtIndex:0]};
    block();
}

打個斷點可見，其中Block的類型：

5.4 Block的復制

• 在全局block調用copy什么也不做
• 在棧上調用copy那么復制到堆上
• 在堆上調用block 引用計數增加

-(void) stackOrHeap{  
    __block int val =10;  
    blkt1 s= ^{  
        return ++val;};  
    s();  
    blkt1 h = [s copy];  
    h();  
}  

不管block配置在何處，用copy方法復制都不會引起任何問題。在ARC環境下，如果不確定是否要copy這個block，那盡管copy即可。

最后的強調，在 ARC 開啟的情況下，除非上面的例外，默認只會有 NSConcreteGlobalBlock 和 NSConcreteMallocBlock 類型的 block。

6. Block的底層研究方法

6.1 研究工具：clang

為了研究編譯器是如何實現 block 的，我們需要使用 clang。clang 提供一個命令，可以將 Objetive-C 的源碼改寫成 c 語言的，借此可以研究 block 具體的源碼實現方式。

首先cd到代碼文件目錄

cd /Users/ChenMan/iOSTest/BlockTestApp

然后執行clang命令

clang -rewrite-objc main.m

其中，main.m的代碼寫好如下

#include <stdio.h>

int main(int argc, char * argv[]) {
    @autoreleasepool {
        typedef void (^blk_t)(void);
        blk_t block = ^{
            printf("Hello, World!\n");
        };
        block();
//        return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class]));
    }
}

執行情況：

你會看到main.cpp

6.2 實現分析

這里只選取部分關鍵代碼。

不難看出int main(int argc, char * argv[]) {就是主函數的實現。

int main(int argc, char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool; 

        typedef void (*blk_t)(void);
        blk_t block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
        ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

    }
}

其中，__main_block_impl_0是block的一個C++的實現(最后面的_0代表是main中的第幾個block)，也就是說也是一個結構體。

(1) __main_block_impl_0

__main_block_impl_0定義如下：

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

(2) __block_impl

如上，其中__block_impl的定義如下：

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

其結構體成員如下：

• isa，指向所屬類的指針，也就是block的類型
• Flags，標志變量，在實現block的內部操作時會用到
• Reserved，保留變量
• FuncPtr，block執行時調用的函數指針

可以看出，它包含了isa指針（包含isa指針的皆為對象），也就是說block也是一個對象(runtime里面，對象和類都是用結構體表示)。

(3) __main_block_desc_0

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

其結構成員含義如下：

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

以上代碼在定義__main_block_desc_0結構體時，同時創建了__main_block_desc_0_DATA，并給它賦值，以供在main函數中對__main_block_impl_0進行初始化。

(4) __main_block_func_0

如上的main函數中，__main_block_func_0也是block的一個C++的實現

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
            printf("Hello, World!\n");
        }

總結：綜合可知

• __main_block_impl_0的 isa 指針指向了_NSConcreteStackBlock。
• 從main函數的main.cpp中看，__main_block_impl_0的 FuncPtr 指向了函數__main_block_func_0。
• __main_block_impl_0的 Desc 也指向了定義__main_block_desc_0時就創建的__main_block_desc_0_DATA，其中紀錄了block結構體大小等信息。

以上就是根據編譯轉換的結果。當然，由于 clang 改寫的具體實現方式和 LLVM 不太一樣，有急切底層興趣的讀者可以進行更深入的研究。