block使用小結、在arc中使用block、如何防止迴圈引用
使用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
此條目是由