block使用小結、在arc中使用block、如何防止迴圈引用

阿新 • • 發佈：2019-01-08

使用block已經有一段時間了，感覺自己瞭解的還行，但是幾天前看到CocoaChina上一個關於block的小測試主題 : 【小測試】你真的知道blocks在Objective-C中是怎麼工作的嗎？，發現竟然做錯了幾道, 才知道自己想當然的理解是錯誤的，所以抽時間學習了下，並且通過一些測試程式碼進行測試，產生這篇部落格。

Block簡介（copy一段）

Block作為C語言的擴充套件，並不是高新技術，和其他語言的閉包或lambda表示式是一回事。需要注意的是由於Objective-C在iOS中不支援GC機制，使用Block必須自己管理記憶體，而記憶體管理正是使用Block坑最多的地方，錯誤的記憶體管理要麼導致return cycle記憶體洩漏要麼記憶體被提前釋放導致crash。 Block的使用很像函式指標，不過與函式最大的不同是：Block可以訪問函式以外、詞法作用域以內的外部變數的值。換句話說，Block不僅實現函式的功能，還能攜帶函式的執行環境。

可以這樣理解，Block其實包含兩個部分內容

Block執行的程式碼，這是在編譯的時候已經生成好的；
一個包含Block執行時需要的所有外部變數值的資料結構。 Block將使用到的、作用域附近到的變數的值建立一份快照拷貝到棧上。

Block與函式另一個不同是，Block類似ObjC的物件，可以使用自動釋放池管理記憶體（但Block並不完全等同於ObjC物件，後面將詳細說明）。

Block基本語法

基本語法在本文就不贅述了，同學們自學。

Block的型別與記憶體管理

根據Block在記憶體中的位置分為三種類型NSGlobalBlock，NSStackBlock, NSMallocBlock。

NSGlobalBlock：類似函式，位於text段；
NSStackBlock：位於棧記憶體，函式返回後Block將無效；
NSMallocBlock：位於堆記憶體。

1、NSGlobalBlock如下，我們可以通過是否引用外部變數識別，未引用外部變數即為NSGlobalBlock，可以當做函式使用。

{
    //create a NSGlobalBlock
    float (^sum)(float, float) = ^(float a, float b){

        return a + b;
    };

    NSLog(@"block is %@", sum); //block is <__NSGlobalBlock__: 0x47d0>
}

2、NSStackBlock如下：

{
    NSArray *testArr = @[@"1", @"2"];

    void (^TestBlock)(void) = ^{

        NSLog(@"testArr :%@", testArr);
    };

    NSLog(@"block is %@", ^{

        NSLog(@"test Arr :%@", testArr);
    });
    //block is <__NSStackBlock__: 0xbfffdac0>
    //列印可看出block是一個 NSStackBlock, 即在棧上, 當函式返回時block將無效

    NSLog(@"block is %@", TestBlock);
    //block is <__NSMallocBlock__: 0x75425a0>
    //上面這句在非arc中列印是 NSStackBlock, 但是在arc中就是NSMallocBlock
    //即在arc中預設會將block從棧複製到堆上，而在非arc中，則需要手動copy.
}

3、NSMallocBlock只需要對NSStackBlock進行copy操作就可以獲取，但是retain操作就不行,會在下面說明

Block的copy、retain、release操作（還是copy一段）

不同於NSObjec的copy、retain、release操作：

Block_copy與copy等效，Block_release與release等效；
對Block不管是retain、copy、release都不會改變引用計數retainCount，retainCount始終是1；
NSGlobalBlock：retain、copy、release操作都無效；
NSStackBlock：retain、release操作無效，必須注意的是，NSStackBlock在函式返回後，Block記憶體將被回收。即使retain也沒用。容易犯的錯誤是[[mutableAarry addObject:stackBlock]，（補：在arc中不用擔心此問題，因為arc中會預設將例項化的block拷貝到堆上）在函數出棧後，從mutableAarry中取到的stackBlock已經被回收，變成了野指標。正確的做法是先將stackBlock copy到堆上，然後加入陣列：[mutableAarry addObject:[[stackBlock copy] autorelease]]。支援copy，copy之後生成新的NSMallocBlock型別物件。
NSMallocBlock支援retain、release，雖然retainCount始終是1，但記憶體管理器中仍然會增加、減少計數。copy之後不會生成新的物件，只是增加了一次引用，類似retain；
儘量不要對Block使用retain操作。

Block對外部變數的存取管理

基本資料型別

1、區域性變數

區域性自動變數，在Block中只讀。Block定義時copy變數的值，在Block中作為常量使用，所以即使變數的值在Block外改變，也不影響他在Block中的值。

{
    int base = 100;
    long (^sum)(int, int) = ^ long (int a, int b) {

        return base + a + b;
    };

    base = 0;
    printf("%ld\n",sum(1,2));
    // 這裡輸出是103，而不是3, 因為塊內base為拷貝的常量 100
}

2、STATIC修飾符的全域性變數

因為全域性變數或靜態變數在記憶體中的地址是固定的，Block在讀取該變數值的時候是直接從其所在記憶體讀出，獲取到的是最新值，而不是在定義時copy的常量.

{
    static int base = 100;
    long (^sum)(int, int) = ^ long (int a, int b) {
        base++;
        return base + a + b;
    };

    base = 0;
    printf("%ld\n",sum(1,2));
    // 這裡輸出是4，而不是103, 因為base被設定為了0
    printf("%d\n", base);
    // 這裡輸出1， 因為sum中將base++了
}

3、__BLOCK修飾的變數

Block變數，被__block修飾的變數稱作Block變數。基本型別的Block變數等效於全域性變數、或靜態變數。

注：BLOCK被另一個BLOCK使用時，另一個BLOCK被COPY到堆上時，被使用的BLOCK也會被COPY。但作為引數的BLOCK是不會發生COPY的

OBJC物件

block對於objc物件的記憶體管理較為複雜，這裡要分static global local block變數分析、還要分非arc和arc分析

非ARC中的變數

先看一段程式碼(非arc)

@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, char *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。

ARC中的變數測試

由於arc中沒有retain，retainCount的概念。只有強引用和弱引用的概念。當一個變數沒有__strong的指標指向它時，就會被系統釋放。因此我們可以通過下面的程式碼來測試。

程式碼片段1(globalObject全域性變數)

NSString *__globalString = nil;

- (void)testGlobalObj
{
    __globalString = @"1";
    void (^TestBlock)(void) = ^{

        NSLog(@"string is :%@", __globalString); //string is  null)
    };

    __globalString = nil;

    TestBlock();
}

- (void)testStaticObj
{
    static NSString *__staticString = nil;
    __staticString = @"1";

    printf("static address: %p\n", &__staticString);    //static address: 0x6a8c

    void (^TestBlock)(void) = ^{

        printf("static address: %p\n", &__staticString); //static address: 0x6a8c

        NSLog(@"string is : %@", __staticString); //string is  null)
    };

    __staticString = nil;

    TestBlock();
}

- (void)testLocalObj
{
    NSString *__localString = nil;
    __localString = @"1";

    printf("local address: %p\n", &__localString); //local address: 0xbfffd9c0

    void (^TestBlock)(void) = ^{

        printf("local address: %p\n", &__localString); //local address: 0x71723e4

        NSLog(@"string is : %@", __localString); //string is : 1
    };

    __localString = nil;

    TestBlock();
}

- (void)testBlockObj
{
    __block NSString *_blockString = @"1";

    void (^TestBlock)(void) = ^{

        NSLog(@"string is : %@", _blockString); // string is  null)
    };

    _blockString = nil;

    TestBlock();
}

- (void)testWeakObj
{
    NSString *__localString = @"1";

    __weak NSString *weakString = __localString;

    printf("weak address: %p\n", &weakString);  //weak address: 0xbfffd9c4
    printf("weak str address: %p\n", weakString); //weak str address: 0x684c

    void (^TestBlock)(void) = ^{

        printf("weak address: %p\n", &weakString); //weak address: 0x7144324
        printf("weak str address: %p\n", weakString); //weak str address: 0x684c

        NSLog(@"string is : %@", weakString); //string is :1
    };

    __localString = nil;

    TestBlock();
}

由以上幾個測試我們可以得出：
1、只有在使用local變數時，block會複製指標，且強引用指標指向的物件一次。其它如全域性變數、static變數、block變數等，block不會拷貝指標,只會強引用指標指向的物件一次。
2、即時標記了為__weak或__unsafe_unretained的local變數。block仍會強引用指標物件一次。（這個不太明白，因為這種寫法可在後面避免迴圈引用的問題）

迴圈引用retain cycle

迴圈引用指兩個物件相互強引用了對方，即retain了對方，從而導致誰也釋放不了誰的記憶體洩露問題。如宣告一個delegate時一般用assign而不能用retain或strong，因為你一旦那麼做了，很大可能引起迴圈引用。在以往的專案中，我幾次用動態記憶體檢查發現了迴圈引用導致的記憶體洩露。

這裡講的是block的迴圈引用問題，因為block在拷貝到堆上的時候，會retain其引用的外部變數，那麼如果block中如果引用了他的宿主物件，那很有可能引起迴圈引用，如：

self.myblock = ^{

            [self doSomething];
        };

為測試迴圈引用，寫了些測試程式碼用於避免迴圈引用的方法，如下，（只有arc的，懶得做非arc測試了）

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

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

經過上面的測試發現，在加了__weak和__unsafe_unretained的變數引入後，TestCycleRetain方法可以正常執行dealloc方法，而不轉換和用__block轉換的變數都會引起迴圈引用。
因此防止迴圈引用的方法如下：
__unsafe_unretained TestCycleRetain *weakSelf = self;

end

此條目是由

block使用小結、在arc中使用block、如何防止迴圈引用

Block簡介（copy一段）

Block基本語法

Block的型別與記憶體管理

Block的copy、retain、release操作（還是copy一段）

Block對外部變數的存取管理

基本資料型別

1、區域性變數

2、STATIC修飾符的全域性變數

3、__BLOCK修飾的變數

注：BLOCK被另一個BLOCK使用時，另一個BLOCK被COPY到堆上時，被使用的BLOCK也會被COPY。但作為引數的BLOCK是不會發生COPY的

OBJC物件

非ARC中的變數

ARC中的變數測試

程式碼片段1(globalObject全域性變數)

迴圈引用retain cycle

block使用時的一些情況以及防止迴圈引用

block使用小結、在arc中使用block、如何防止迴圈引用

2、Struts中接收、傳遞資料

探討OC的記憶體管理以及防止迴圈引用retain cycle 代理為什麼用weak block為什麼用copy

運用block，防止迴圈引用

oracle 表結構、表字段、表中資料、主鍵約束的相關操作

解決Eclipse中Java工程間迴圈引用而報錯的問題

如何防止迴圈引用 assign

iOS 防止迴圈引用的兩個方法

swift中解決閉包迴圈引用的幾種方式

CUDA中grid、block、thread、warp與SM、SP的關係

iOS中block的詳解weakSelf、strongSelf,以及block迴圈引用的避免。

個人對於OC中delegate、block的簡單理解

iOS中block的詳解weakSelf、strongSelf

iOS Block傳值、代理傳值、通知中心

ARC中的block

【精】iOS知識樹，知識點（包括物件、Block、訊息轉發、GCD、執行時、runloop、動畫、Push、KVO、tableview，UIViewController、提交AppStore）

在javascript中密封、凍結和防止物件擴充套件

swift ARC中的strong、weak、unowned

iOS之block、weak、Block迴圈引用、__weak typeof(self) weakSelf = self;

block使用小結、在arc中使用block、如何防止迴圈引用

Block簡介（copy一段）

Block基本語法

Block的型別與記憶體管理

Block的copy、retain、release操作 （還是copy一段）

Block對外部變數的存取管理

基本資料型別

1、區域性變數

2、STATIC修飾符的全域性變數

3、__BLOCK修飾的變數

注：BLOCK被另一個BLOCK使用時，另一個BLOCK被COPY到堆上時，被使用的BLOCK也會被COPY。但作為引數的BLOCK是不會發生COPY的

OBJC物件

非ARC中的變數

ARC中的變數測試

程式碼片段1(globalObject全域性變數)

迴圈引用retain cycle

相關推薦

Block的copy、retain、release操作（還是copy一段）