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,可以當做函數使用。
1
2
3
4
5
6
7
8
9
|
{ //create a NSGlobalBlock float
(^sum)( float ,
float ) = ^( float
a, float
b){ return
a + b; }; NSLog ( @"block is %@" ,
sum); //block is <__NSGlobalBlock__: 0x47d0> } |
2、NSStackBlock如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
{ 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中的值。
1
2
3
4
5
6
7
8
9
10
11
|
{ 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的常量.
1
2
3
4
5
6
7
8
9
10
11
12
13
|
{ 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
@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全局變量)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
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中如果引用了他的宿主對象,那很有可能引起循環引用,如:
1
2
3
4
|
self .myblock = ^{ [ self
doSomething]; }; |
爲測試循環引用,寫了些測試代碼用於避免循環引用的方法,如下,(只有arc的,懶得做非arc測試了)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
- ( 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