深入理解iOS的block (下)-有解無憂

物件型別的auto變數

例子一

首先看一個簡單的例子
定義一個類 YZPerson,里面只有一個dealloc方法

@interface YZPerson : NSObject
@property (nonatomic ,assign) int age;
@end

@implementation YZPerson

- (void)dealloc
{
 NSLog(@"%s",__func__);
}

@end

如下代碼使用

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

 {
 YZPerson *person = [[YZPerson alloc]init];
 person.age = 10;
 }
 NSLog(@"-----");
 }
 return 0;
}

想必大家都能知道會輸出什么,沒錯，就是person先銷毀，然后列印----- 因為person是在大括號內，當大括號執行完之后，person 就銷毀了，

iOS-block[1376:15527] -[YZPerson dealloc]
iOS-block[1376:15527] -----

例子二

上面的例子，是不是挺簡單，那下面這個呢，

// 定義block
typedef void (^YZBlock)(void);

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

 YZBlock block;

 {
 YZPerson *person = [[YZPerson alloc]init];
 person.age = 10;

 block = ^{
 NSLog(@"---------%d", person.age);
 };

 NSLog(@"block.class = %@",[block class]);
 }
 NSLog(@"block銷毀");

 }
 return 0;
}

如下結果，輸出可知當 block為__NSMallocBlock__型別時候，block可以保住person的命的，因為person離開大括號之后沒有銷毀，當block銷毀，person才銷毀

iOS-block[3186:35811] block.class = __NSMallocBlock__
iOS-block[3186:35811] block銷毀
iOS-block[3186:35811] -[YZPerson dealloc]

一個開發者，有一個學習的氛圍跟一個交流圈子特別重要，這是一個我的iOS交流群：1012951431，分享BAT,阿里面試題、面試經驗，討論技術，大家一起交流學習成長！希望幫助開發者少走彎路，

分析

終端執行這行指令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m把main.m生成main.cpp
可以看到如下代碼

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 YZPerson *person;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, YZPerson *_person, int flags=0) : person(_person) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

很明顯就是這個block里面包含 YZPerson *person，

MRC下 block參考實體物件

上面的例子，是不是挺簡單，那如果是MRC下呢

// 定義block
typedef void (^YZBlock)(void);

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

 YZBlock block;

 {
 YZPerson *person = [[YZPerson alloc]init];
 person.age = 10;

 block = ^{
 NSLog(@"---------%d", person.age);
 };

 NSLog(@"block.class = %@",[block class]);

 // MRC下，需要手動釋放
 [person release];
 }
 NSLog(@"block銷毀");
 // MRC下，需要手動釋放
 [block release];
 }
 return 0;
}

輸出結果為

iOS-block[3114:34894] block.class = __NSStackBlock__
iOS-block[3114:34894] -[YZPerson dealloc]
iOS-block[3114:34894] block銷毀

和上面的對比，區別就是，還沒有執行NSLog(@"block銷毀");的時候，[YZPerson dealloc]已經執行了，也就是說，person 離開大括號，就銷毀了，

輸出可知當 block為__NSStackBlock__型別時候，block不可以保住person的命的

MRC下 [block copy]參考實體物件

在MRC下，對block執行了copy操作

// 定義block
typedef void (^YZBlock)(void);

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

 YZBlock block;

 {
 YZPerson *person = [[YZPerson alloc]init];
 person.age = 10;

 block = [^{
 NSLog(@"---------%d", person.age);
 } copy];

 NSLog(@"block.class = %@",[block class]);
 // MRC下，需要手動釋放
 [person release];
 }

 NSLog(@"block銷毀");
 [block release];
 }
 return 0;

輸出結果為,可知當 block為__NSMallocBlock__型別時候，block是可以保住person的命的

iOS-block[3056:34126] block.class = __NSMallocBlock__
iOS-block[3056:34126] block銷毀
iOS-block[3056:34126] -[YZPerson dealloc]

`__weak`修飾

如下代碼

// 定義block
typedef void (^YZBlock)(void);

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

 YZBlock block;

 {
 YZPerson *person = [[YZPerson alloc]init];
 person.age = 10;

 __weak YZPerson *weakPerson = person;

 block = ^{
 NSLog(@"---------%d", weakPerson.age);
 };

 NSLog(@"block.class = %@",[block class]);
 }

 NSLog(@"block銷毀");
 }
 return 0;
}

輸出為

iOS-block[3687:42147] block.class = __NSMallocBlock__
iOS-block[3687:42147] -[YZPerson dealloc]
iOS-block[3687:42147] block銷毀

生成cpp檔案
注意：
在使用clang轉換OC為C++代碼時，可能會遇到以下問題
cannot create __weak reference in file using manual reference
解決方案：支持ARC、指定運行時系統版本，比如
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

生成之后，可以看到，如下代碼，MRC情況下，生成的代碼明顯多了,這是因為ARC自動進行了copy操作

//copy 函式
 void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);

 //dispose函式
 void (*dispose)(struct __main_block_impl_0*);

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 //weak修飾
 YZPerson *__weak weakPerson;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, YZPerson *__weak _weakPerson, int flags=0) : weakPerson(_weakPerson) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

static struct __main_block_desc_0 {
 size_t reserved;
 size_t Block_size;
 //copy 函式
 void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);

 //dispose函式
 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
};

//copy函式內部會呼叫_Block_object_assign函式
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {

//asssgin會對物件進行強參考或者弱參考
_Block_object_assign((void*)&dst->person, 
(void*)src->person, 
3/*BLOCK_FIELD_IS_OBJECT*/);
}

//dispose函式內部會呼叫_Block_object_dispose函式
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
_Block_object_dispose((void*)src->person, 
3/*BLOCK_FIELD_IS_OBJECT*/);
}

小結

無論是MAC還是ARC

當block為__NSStackBlock__型別時候，是在堆疊空間，無論對外面使用的是strong 還是weak 都不會對外面的物件進行強參考
當block為__NSMallocBlock__型別時候，是在堆空間，block是內部的_Block_object_assign函式會根據strong或者 weak對外界的物件進行強參考或者弱參考，

其實也很好理解，因為block本身就在堆疊上，自己都隨時可能消失，怎么能保住別人的命呢？

當block內部訪問了物件型別的auto變數時
- 如果block是在堆疊上，將不會對auto變數產生強參考
如果block被拷貝到堆上
- 會呼叫block內部的copy函式
- copy函式內部會呼叫_Block_object_assign函式
- _Block_object_assign函式會根據auto變數的修飾符（__strong、__weak、__unsafe_unretained）做出相應的操作，形成強參考（retain）或者弱參考
如果block從堆上移除
- 會呼叫block內部的dispose函式
- dispose函式內部會呼叫_Block_object_dispose函式
- _Block_object_dispose函式會自動釋放參考的auto變數（release）

函式	呼叫時機
copy函式	堆疊上的Block復制到堆上
dispose函式	堆上的block被廢棄時

`__block`

先從一個簡單的例子說起，請看下面的代碼

// 定義block
typedef void (^YZBlock)(void);

int age = 10;
YZBlock block = ^{
 NSLog(@"age = %d", age);
};
block();

代碼很簡單，運行之后，輸出

age = 10

上面的例子在block中訪問外部區域變數，那么問題來了，如果想在block內修改外部區域的值，怎么做呢？

修改區域變數的三種方法

寫成全域變數

我們把a定義為全域變數，那么在哪里都可以訪問，

// 定義block
typedef void (^YZBlock)(void);
 int age = 10;

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

 YZBlock block = ^{
 age = 20;
 NSLog(@"block內部修改之后age = %d", age);
 };

 block();
 NSLog(@"block呼叫完 age = %d", age);
 }
 return 0;
}

這個很簡單，輸出結果為

block內部修改之后age = 20
block呼叫完 age = 20

對于輸出就結果也沒什么問題，因為全域變數，是所有地方都可訪問的，在block內部可以直接操作age的記憶體地址的，呼叫完block之后，全域變數age指向的地址的值已經被更改為20，所以是上面的列印結果

static修改區域變數

// 定義block
typedef void (^YZBlock)(void);

int main(int argc, const char * argv[]) {
 @autoreleasepool {
 static int age = 10;
 YZBlock block = ^{
 age = 20;
 NSLog(@"block內部修改之后age = %d", age);
 };

 block();
 NSLog(@"block呼叫完 age = %d", age);
 }
 return 0;
}

上面的代碼輸出結果為

block內部修改之后age = 20
block呼叫完 age = 20

終端執行這行指令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m把main.m生成main.cpp
可以看到如下代碼

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 int *age;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_age, int flags=0) : age(_age) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

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

 (*age) = 20;
 NSLog((NSString *)&__NSConstantStringImpl__var_folders_x4_920c4yq936b63mvtj4wmb32m0000gn_T_main_5dbaa1_mi_0, (*age));
}

可以看出，當區域變數用static修飾之后，這個block內部會有個成員是int *age，也就是說把age的地址捕獲了，這樣的話，當然在block內部可以修改區域變數age了，

以上兩種方法，雖然可以達到在block內部修改區域變數的目的，但是，這樣做，會導致記憶體無法釋放，無論是全域變數，還是用static修飾，都無法及時銷毀，會一直存在記憶體中，很多時候，我們只是需要臨時用一下，當不用的時候，能銷毀掉，那么第三種，也就是今天的主角 __block隆重登場

`__block`來修飾

代碼如下

// 定義block
typedef void (^YZBlock)(void);

int main(int argc, const char * argv[]) {
 @autoreleasepool {
 __block int age = 10;
 YZBlock block = ^{
 age = 20;
 NSLog(@"block內部修改之后age = %d",age);
 };

 block();
 NSLog(@"block呼叫完 age = %d",age);
 }
 return 0;
}

輸出結果和上面兩種一樣

block內部修改之后age = 20
block呼叫完 age = 20

`__block`分析

終端執行這行指令xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m把main.m生成main.cpp

首先能發現多了__Block_byref_age_0結構體

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 // 這里多了__Block_byref_age_0型別的結構體
 __Block_byref_age_0 *age; // by ref
 // fp是函式地址  desc是描述資訊  __Block_byref_age_0 型別的結構體  *_age  flags標記
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp; //fp是函式地址
 Desc = desc;
 }
};

再仔細看結構體__Block_byref_age_0，可以發現第一個成員變數是isa指標，第二個是指向自身的指標__forwarding


// 結構體 __Block_byref_age_0
struct __Block_byref_age_0 {
 void *__isa; //isa指標
 __Block_byref_age_0 *__forwarding; // 指向自身的指標
 int __flags;
 int __size;
 int age; //使用值
};

查看main函式里面的代碼

 // 這是原始的代碼 __Block_byref_age_0
 __attribute__((__blocks__(byref))) __Block_byref_age_0 age = {
 (void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};

// 這是原始的 block代碼
YZBlock block = ((void (*)())&__main_block_impl_0(
(void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_age_0 *)&age, 570425344));

代碼太長，簡化一下，去掉一些強轉的代碼，結果如下

// 這是原始的代碼 __Block_byref_age_0
__attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};

//這是簡化之后的代碼 __Block_byref_age_0
__Block_byref_age_0 age = {
 0, //賦值給 __isa
 (__Block_byref_age_0 *)&age,//賦值給 __forwarding,也就是自身的指標
 0, // 賦值給__flags
 sizeof(__Block_byref_age_0),//賦值給 __size
 10 // age 使用值
 };

// 這是原始的 block代碼
YZBlock block = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_age_0 *)&age, 570425344));

// 這是簡化之后的 block代碼
YZBlock block = (&__main_block_impl_0(
 __main_block_func_0,
 &__main_block_desc_0_DATA,
 &age,
 570425344));

 ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
 //簡化為
block->FuncPtr(block);

其中__Block_byref_age_0結構體中的第二個(__Block_byref_age_0 *)&age賦值給上面代碼結構體__Block_byref_age_0中的第二個__Block_byref_age_0 *__forwarding,所以__forwarding 里面存放的是指向自身的指標

//這是簡化之后的代碼 __Block_byref_age_0
__Block_byref_age_0 age = {
 0, //賦值給 __isa
 (__Block_byref_age_0 *)&age,//賦值給 __forwarding,也就是自身的指標
 0, // 賦值給__flags
 sizeof(__Block_byref_age_0),//賦值給 __size
 10 // age 使用值
 };

結構體__Block_byref_age_0中代碼如下，第二個__forwarding存放指向自身的指標,第五個age里面存放區域變數

// 結構體 __Block_byref_age_0
struct __Block_byref_age_0 {
 void *__isa; //isa指標
 __Block_byref_age_0 *__forwarding; // 指向自身的指標
 int __flags;
 int __size;
 int age; //使用值
};

呼叫的時候，先通過__forwarding找到指標，然后去取出age值，

(age->__forwarding->age));

小結

__block可以用于解決block內部無法修改auto變數值的問題
__block不能修飾全域變數、靜態變數（static）
- 編譯器會將__block變數包裝成一個物件

呼叫的是，從__Block_byref_age_0的指標找到 age所在的記憶體，然后修改值

記憶體管理問題

bloc訪問OC物件

代碼如下

當block內部訪問外面的OC物件的時候

eg:

// 定義block
typedef void (^YZBlock)(void);

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

 NSObject *obj = [[NSObject alloc]init];
 YZBlock block = ^{
 NSLog(@"%p",obj);
 };
 block();
 }
 return 0;
}

在終端使用clang轉換OC為C++代碼

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

因為是在ARC下，所以會copy，堆疊上拷貝到堆上，結構體__main_block_desc_0中有copy和dispose

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

copy會呼叫 __main_block_copy_0

static void __main_block_copy_0(struct __main_block_impl_0*dst, 
struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->obj, 
(void*)src->obj, 3/*BLOCK_FIELD_IS_OBJECT*/);}

其內部的_Block_object_assign會根據代碼中的修飾符 strong或者weak而對其進行強參考或者弱參考，

查看__main_block_impl_0

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 //strong 強參考
 NSObject *__strong obj;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *__strong _obj, int flags=0) : obj(_obj) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

可以看上修飾符是strong，所以，呼叫_Block_object_assign時候，會對其進行強參考，

由前面可知

當block在堆疊上時，并不會對__block變數產生強參考
當block被copy到堆時
- 會呼叫block內部的copy函式
- copy函式內部會呼叫_Block_object_assign函式
- _Block_object_assign函式會對__block變數形成強參考（retain）
當block從堆中移除時
- 會呼叫block內部的dispose函式
- dispose函式內部會呼叫_Block_object_dispose函式
- _Block_object_dispose函式會自動釋放參考的__block變數（release）

拷貝

拷貝的時候，

會呼叫block內部的copy函式
- copy函式內部會呼叫_Block_object_assign函式
- _Block_object_assign函式會對__block變數形成強參考（retain）
中我們知道，如下代碼

__block int age = 10;
 YZBlock block = ^{
 age = 20;
 NSLog(@"block內部修改之后age = %d",age);
 };

區域變數age是在堆疊上的，在block內部參考age,但是當block從堆疊上拷貝到堆上的時候，怎么能保證下次block訪問age的時候，能訪問到呢？因為我們知道堆疊上的區域變數，隨時會銷毀的，

假設現在有兩個堆疊上的block,分別是block0和block1,同時參考了了堆疊上的__block變數，現在對block0進行copy操作，我們知道，堆疊上的block進行copy，就會復制到堆上，也就是說block0會復制到堆上，因為block0持有__block變數，所以也會把這個__block變數復制到堆上，同時堆上的block0對堆上的__block變數是強參考，這樣能達到block0隨時能訪問__block變數，

還是上面的例子，剛才block0拷貝到堆上了，現在如果block1也拷貝到堆上，因為剛才變數已經拷貝到堆上，就不需要再次拷貝，只需要把堆上的block1也強參考堆上的變數就可以了，

釋放

當釋放的時候

會呼叫block內部的dispose函式
- dispose函式內部會呼叫_Block_object_dispose函式
- _Block_object_dispose函式會自動釋放參考的__block變數（release）

上面的代碼中，如果在堆上只有一個block參考__block變數,當block銷毀時候，直接銷毀堆上的__block變數，但是如果有兩個block參考__block變數，就需要當兩個block都廢棄的時候，才會廢棄__block變數，

其實，說到底，就是誰使用，誰負責

物件型別的`auto變數`、`__block`變數

把前面的都放在一起整理一下，有 auto 變數 num , __block變數int, obj 和weakObj2如下

 __block int age = 10;
 int num = 8;
 NSObject *obj = [[NSObject alloc]init];
 NSObject *obj2 = [[NSObject alloc]init];
 __weak NSObject *weakObj2 = obj2;
 YZBlock block = ^{
 NSLog(@"age = %d",age);
 NSLog(@"num = %d",num);
 NSLog(@"obj = %p",obj);
 NSLog(@"weakObj2 = %p",weakObj2);
 NSLog(@"block內部修改之后age = %d",age);
 };

block();

執行終端指令

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

生成代碼如下所示

被__block修飾的物件型別

當__block變數在堆疊上時，不會對指向的物件產生強參考
當__block變數被copy到堆時
- 會呼叫__block變數內部的copy函式
- copy函式內部會呼叫_Block_object_assign函式
- _Block_object_assign函式會根據所指向物件的修飾符（__strong、__weak、__unsafe_unretained）做出相應的操作，形成強參考（retain）或者弱參考（注意：這里僅限于ARC時會retain，MRC時不會retain）
如果__block變數從堆上移除
- 會呼叫__block變數內部的dispose函式
- dispose函式內部會呼叫_Block_object_dispose函式
- _Block_object_dispose函式會自動釋放指向的物件（release）

`block`的`forwarding`指標

//結構體__Block_byref_obj_0中有__forwarding
 struct __Block_byref_obj_0 {
 void *__isa;
 __Block_byref_obj_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 NSObject *__strong obj;
};

// 訪問的時候
age->__forwarding->age

為啥什么不直接用age,而是age->__forwarding->age呢？

這是因為，如果__block變數在堆疊上，就可以直接訪問，但是如果已經拷貝到了堆上，訪問的時候，還去訪問堆疊上的，就會出問題，所以，先根據__forwarding找到堆上的地址，然后再取值

總結

當block在堆疊上時，對它們都不會產生強參考
當block拷貝到堆上時，都會通過copy函式來處理它們
- __block變數（假設變數名叫做a）
_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
物件型別的auto變數（假設變數名叫做p）
_Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);
當block從堆上移除時，都會通過dispose函式來釋放它們
__block變數（假設變數名叫做a）
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);
物件型別的auto變數（假設變數名叫做p）
_Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);

回圈參考問題

繼續探索一下block的回圈參考問題，

看如下代碼，有個Person類，里面兩個屬性，分別是block和age

#import <Foundation/Foundation.h>

typedef void (^YZBlock) (void);

@interface YZPerson : NSObject
@property (copy, nonatomic) YZBlock block;
@property (assign, nonatomic) int age;
@end

#import "YZPerson.h"

@implementation YZPerson
- (void)dealloc
{
 NSLog(@"%s", __func__);
}
@end

main.m中如下代碼

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

 YZPerson *person = [[YZPerson alloc] init];
 person.age = 10;
 person.block = ^{
 NSLog(@"person.age--- %d",person.age);
 };
 NSLog(@"--------");

 }
 return 0;
}

輸出只有

iOS-block[38362:358749] ——–

也就是說程式結束，person都沒有釋放，造成了記憶體泄漏，

回圈參考原因

下面這行代碼，是有個person指標，指向了YZPerson物件

YZPerson *person = [[YZPerson alloc] init];

執行完

person.block = ^{
 NSLog(@"person.age--- %d",person.age);
 };

之后，block內部有個強指標指向person，下面代碼生成cpp檔案

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 //強指標指向person
 YZPerson *__strong person;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, YZPerson *__strong _person, int flags=0) : person(_person) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

而block是person的屬性

@property  (copy, nonatomic) YZBlock block;

當程式退出的時候，區域變數person銷毀，但是由于MJPerson和block直接，互相強參考，誰都釋放不了，

`__weak`解決回圈參考

為了解決上面的問題，只需要用__weak來修飾，即可

int main(int argc, const char * argv[]) {
 @autoreleasepool {
 YZPerson *person = [[YZPerson alloc] init];
 person.age = 10;

 __weak YZPerson *weakPerson = person;

 person.block = ^{
 NSLog(@"person.age--- %d",weakPerson.age);
 };
 NSLog(@"--------");

 }
 return 0;
}

編譯完成之后是

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 // block內部對weakPerson是弱參考
 YZPerson *__weak weakPerson;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, YZPerson *__weak _weakPerson, int flags=0) : weakPerson(_weakPerson) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

當區域變數消失時候，對于YZPseson來說，只有一個若指標指向它，那它就銷毀，然后block也銷毀，

`__unsafe_unretained`解決回圈參考

除了上面的__weak之后，也可以用__unsafe_unretained來解決回圈參考

int main(int argc, const char * argv[]) {
 @autoreleasepool {
 YZPerson *person = [[YZPerson alloc] init];
 person.age = 10;

 __unsafe_unretained YZPerson *weakPerson = person;

 person.block = ^{
 NSLog(@"person.age--- %d",weakPerson.age);
 };
 NSLog(@"--------");

 }
 return 0;
}

對于的cpp檔案為

struct __main_block_impl_0 {
 struct __block_impl impl;
 struct __main_block_desc_0* Desc;
 YZPerson *__unsafe_unretained weakPerson;
 __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, YZPerson *__unsafe_unretained _weakPerson, int flags=0) : weakPerson(_weakPerson) {
 impl.isa = &_NSConcreteStackBlock;
 impl.Flags = flags;
 impl.FuncPtr = fp;
 Desc = desc;
 }
};

雖然__unsafe_unretained可以解決回圈參考，但是最好不要用，因為

__weak：不會產生強參考，指向的物件銷毀時，會自動讓指標置為nil
__unsafe_unretained：不會產生強參考，不安全，指向的物件銷毀時，指標存盤的地址值不變

`__block`解決回圈參考

eg:

int main(int argc, const char * argv[]) {
 @autoreleasepool {
 __block YZPerson *person = [[YZPerson alloc] init];
 person.age = 10;
 person.block = ^{
 NSLog(@"person.age--- %d",person.age);
 //這一句不能少
 person = nil;
 };
 // 必須呼叫一次
 person.block();
 NSLog(@"--------");
 }
 return 0;
}

上面的代碼中，也是可以解決回圈參考的，但是需要注意的是，person.block();必須呼叫一次，為了執行person = nil;.

對應的結果如下

下面的代碼，block會對__block產生強參考

__block YZPerson *person = [[YZPerson alloc] init];
person.block = ^{
 NSLog(@"person.age--- %d",person.age);
 //這一句不能少
 person = nil;
};

person物件本身就對block是強參考

@property  (copy, nonatomic) YZBlock block;

__block對person產生強參考

struct __Block_byref_person_0 {
 void *__isa;
__Block_byref_person_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 //`__block`對person產生強參考
 YZPerson *__strong person;
};

所以他們的參考關系如圖

當執行完person = nil時候,__block解除對person的參考,進而，全都解除釋放了，
但是必須呼叫person = nil才可以，否則，不能解除回圈參考

小結

通過前面的分析，我們知道，ARC下，上面三種方式對比，最好的是__weak

MRC下注意點

如果再MRC下，因為不支持弱指標__weak，所以，只能是__unsafe_unretained或者__block來解決回圈參考

結束

回到最開始的問題

block的原理是怎樣的？本質是什么？
__block的作用是什么？有什么使用注意點？
block的屬性修飾詞為什么是copy？使用block有哪些使用注意？
block一旦沒有進行copy操作，就不會在堆上
block在修改NSMutableArray，需不需要添加__block？

現在是不是心中有了自己的答案呢？

另外，如果你想一起進階，不妨添加一下交流群1012951431，選擇加入一起交流，一起學習，期待你的加入！

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/4168.html

標籤：iOS

上一篇：七牛-ETag演算法（OC）

下一篇：阿里、位元組：一套高效的iOS面試題

深入理解iOS的block (下)

物件型別的auto變數

例子一

例子二

分析

MRC下 block參考實體物件

MRC下 [block copy]參考實體物件

__weak修飾

小結

__block

修改區域變數的三種方法

寫成全域變數

static修改區域變數

__block來修飾

__block分析

小結

記憶體管理問題

bloc訪問OC物件

代碼如下

拷貝

釋放

物件型別的auto變數、__block變數

被__block修飾的物件型別

__block的__forwarding指標

總結

回圈參考問題

回圈參考原因

__weak解決回圈參考

__unsafe_unretained解決回圈參考

__block解決回圈參考

小結

MRC下注意點

結束

`__weak`修飾

`__block`

`__block`來修飾

`__block`分析

物件型別的`auto變數`、`__block`變數

`block`的`forwarding`指標

`__weak`解決回圈參考

`__unsafe_unretained`解決回圈參考

`__block`解決回圈參考