[关闭]
@qidiandasheng 2022-08-14T17:52:42.000000Z 字数 14863 阅读 3325

iOS里关于block的一些理解（😁）

iOS实战

介绍

block实际上就是Objective-C语言对于闭包的实现。
block配合上dispatch_queue，可以方便地实现简单的多线程编程和异步编程。
（闭包是一个函数（或指向函数的指针），再加上该函数执行的外部的上下文变量（有时候也称作自由变量）。）

Block本质是Objective-C的对象，虽然实现了闭包，但并不是函数指针。以下是Block的源码，所以准确的说Block是一个里面存储了指向定义block 时的代码块的函数指针，以及block外部上下文变量信息的结构体。

  1. struct Block_layout {
  2.     void *isa;
  3.     int flags;
  4.     int reserved;
  5.     void (*invoke)(void *, ...);
  6.     struct Block_descriptor *descriptor;
  7.     /* Imported variables. */
  8. };

当我们声明一个Block的时候，编译器其实会将Block转换成以上struct结构体。
其中isa指向的是Block具体的类。有如下6种，其中StackBlock、MallocBlock、GlobalBlock是比较常见的。

  1. /* the raw data space for runtime classes for blocks */
  2. /* class+meta used for stack, malloc, and collectable based blocks */
  3. BLOCK_EXPORT void * _NSConcreteStackBlock[32];
  4. BLOCK_EXPORT void * _NSConcreteMallocBlock[32];
  5. BLOCK_EXPORT void * _NSConcreteAutoBlock[32];
  6. BLOCK_EXPORT void * _NSConcreteFinalizingBlock[32];
  7. BLOCK_EXPORT void * _NSConcreteGlobalBlock[32];
  8. BLOCK_EXPORT void * _NSConcreteWeakBlockVariable[32];

分析简单的 Block C++ 源代码

OC代码：

  1. - (void)viewDidLoad {
  2.     [super viewDidLoad];
  3.     int b = 10;
  4.     void(^testBlock)(int) = ^(int a) {
  5.         NSLog(@"%d",a+b);
  6.     };
  7.     b = 2;
  8.     testBlock(5);
  9. }

C++源码：

  1. struct __block_impl {
  2.   void *isa;
  3.   int Flags;
  4.   int Reserved;
  5.   void *FuncPtr;
  6. };
  8. static struct __ViewController__viewDidLoad_block_desc_0 {
  9.   size_t reserved;
  10.   size_t Block_size;
  11. }
  13. struct __ViewController__viewDidLoad_block_impl_0 {
  14.   struct __block_impl impl;
  15.   struct __ViewController__viewDidLoad_block_desc_0* Desc;
  16.   int b;
  17.   __ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int _b, int flags=0) : b(_b) {
  18.     impl.isa = &_NSConcreteStackBlock;
  19.     impl.Flags = flags;
  20.     impl.FuncPtr = fp;
  21.     Desc = desc;
  22.   }
  23. };

通过分析上面源码，我们可以得到下面几点结论：

改为局部静态变量

我们把上面的int b改为static int b，看一下C++源码会变成什么样？

  1. struct __ViewController__viewDidLoad_block_impl_0 {
  2.   struct __block_impl impl;
  3.   struct __ViewController__viewDidLoad_block_desc_0* Desc;
  4.   int *b;  //主要区别
  5.   __ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int *_b, int flags=0) : b(_b) {
  6.     impl.isa = &_NSConcreteStackBlock;
  7.     impl.Flags = flags;
  8.     impl.FuncPtr = fp;
  9.     Desc = desc;
  10.   }
  11. };

我们看到之前是指传递，现在变成了指针传递，因为static的生命周期是整个运行期间，内存在静态数据区，所以只要指针传递就能靠指针来访问。

block的写法

回传值(^名字)(参数列)

Xcode快捷键：inlineBlock

  1. //声明一个square的Block Pointer，其所指向的Block有一个int输入和int输出  
  2. typedef int (^square)(int);  
  3. //将Block实体指定给square  
  4. square = ^(int a){ return a*a ; };  
  5. //调用方法，感觉是是不是很像function的用法？  
  6. int result = square(5);  
  7. NSLog(@"%d", result);

方法的传入值

当其作为Object-C method的传入值的话，需要把类型写在变量前面，然后加上小括号。比如下面这种写法：

  1. //square参数的类型是int(^)(int)  
  2. -(void)objcMethod:(int(^)(int))square;

声明block属性

  1. @property (nonatomic,copy) void (^ callBack)(NSDictionary *);

block阵列的使用

  1. {
  2.     void (^blocks[3])(void);
  3.     for (NSInteger i = 0; i < 3; i++) {
  4.         blocks[i] = ^{
  5.             NSLog(@"Hello:%i", i);
  6.         };
  7.     }
  8.     blocks[0](); //result:Hello:0
  9.     blocks[1](); //result:Hello:1
  10.     blocks[2](); //result:Hello:2
  11. }

存取变量

Block将使用到的、作用域附近的变量的值建立一份快照拷贝到栈上。

读取和Block pointer同一个Scope的变量值

  1. {  
  2.     int outA = 8;  
  3.     int (^myPtr)(int) = ^(int a){ return outA + a;};  
  4.     //block里面可以读取同一类型的outA的值  
  5.     int result = myPtr(3);  // result is 11  
  6.     NSLog(@"result=%d", result);  
  7. }

下面这一段代码就不一样了

  1. {
  2.     int outA = 8;  
  3.     int (^myPtr)(int) = ^(int a){ return outA + a;};//block里面可以读取同一类型的outA的值  
  4.     outA = 5;  //在调用myPtr之前改变outA的值  
  5.     int result = myPtr(3);  // result的值仍然是11，并不是8  
  6.     NSLog(@"result=%d", result);  
  7. }

为什么result 的值仍然是11？而不是8呢？事实上，myPtr在其主体中用到的outA这个变量值的时候做了一个copy的动作，把outA的值copy下来，在Block中作为常量使用。所以，之后outA即使换成了新的值，对于myPtr里面copy的值是没有影响的。（类似于深拷贝）

我们也可以看对应的Block的C++实现，我们能看到在_main_block_impl_0这个结构体中我们发现多了一个int类型的成员变量outA，在结构体的构造函数中多了一个参数int _outA，并且用这个int _outA去初始化成员变量outA。
所以在void (*block)(void) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, a);中传入了自动变量a用来初始化_main_block_impl_0的成员变量outA。那这个时候_main_block_impl_0的成员变量outA就被赋值为8了。
由于上面这一步是值传递，所以当执行outA = 5时，_main_block_impl_0结构体的成员变量outA的值是不会随之改变的，仍然是8。

  1. int outA = 8;
  3. int (*block)(int) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, outA);
  5. outA = 5;
  7. block->FuncPtr)(block);
  1. struct __main_block_impl_0 {
  2.   struct __block_impl impl;
  3.   struct __main_block_desc_0* Desc;
  4.   int a; //这是新加入的成员变量
  5.   __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _outA, int flags=0) : outA(_outA) {
  6.     impl.isa = &_NSConcreteStackBlock;
  7.     impl.Flags = flags;
  8.     impl.FuncPtr = fp;
  9.     Desc = desc;
  10.   }
  11. };

需要注意的是，这里copy的值是变量的值，如果它是一个记忆体的位置（地址），换句话说，就是这个变量是个指针的话，它的值是可以在block里被改变的。(相当于浅拷贝，拷贝的只是一个指针地址，对象地址还是没变的)

  1. {  
  2.     NSMutableArray *mutableArray = [NSMutableArray arrayWithObjects:@"one", @"two", @"three", nil];  
  3.     int result = ^(int a){[mutableArray removeLastObject]; return a*a;}(5);  
  4.     NSLog(@"test array :%@", mutableArray);  
  5. }  
  7. //原本mutableArray的值是{@"one",@"two",@"three"}，在block里面被更改mutableArray后，就变成{@"one", @"two"}了。

直接存取static类型的变量

因为全局变量或静态变量在内存中的地址是固定的，Block在读取该变量值的时候是直接从其所在内存读出，获取到的是最新值，而不是在定义时copy的常量。

  1. {  
  2.     static int outA = 8;  
  3.     int (^myPtr)(int) = ^(int a){return outA + a;};  
  4.     outA = 5;  
  5.     int result = myPtr(3);  
  6.     //result的值是8，因为outA是static类型的变量 (该变量在全局数据区分配内存,但作用域还是局部作用域) 
  7.     NSLog(@"result=%d", result);     
  8. }

Block Variable类型的变量

在某个变量前面如果加上修饰字“__block”的话（注意，block前面有两个下划线），这个变量就称作block variable。基本类型的Block变量等效于全局变量、或静态变量。即将“外部变量”在栈中的内存地址放到了堆中。

那么在block里面就可以任意修改此变量的值，如下代码：

  1. {  
  2.     __block int num = 5;  
  3.     NSLog(@"定义前：%p", &num); 
  4.     int (^myPtr)(int) = ^(int a){
  5.                             NSLog(@"block内部：%p", &num);
  6.                             return num++;                                             };  
  8.     int (^myPtr2)(int) = ^(int a){
  9.                             NSLog(@"block内部：%p", &num);
  10.                             return num++;
  11.                             };  
  12.     int result = myPtr(0);   //result的值为5，num的值为6  
  13.     result = myPtr2(0);      //result的值为6，num的值为7 
  14.     NSLog(@"定义后：%p", &num);
  15.     NSLog(@"result=%d", result);      
  16. }

输出（我们看到num进入block之后内存地址其实改变了，也就是block 内部的变量会被 copy 到堆区）：

  1. 2016-09-12 16:24:16.622 test[20146:972930] 定义前：0x7fff5caf0a78
  2. 2016-09-12 16:24:16.623 test[20146:972930] block内部：0x7ff539c0b1a8
  3. 2016-09-12 16:24:16.623 test[20146:972930] block内部：0x7ff539c0b1a8
  4. 2016-09-12 16:24:16.623 test[20146:972930] 定义后：0x7ff539c0b1a8
  5. 2016-09-12 16:24:16.623 test[20146:972930] result=6

本质上加入__block之后，是变成了一个__Block_byref_val_0结构体：

  1. __block int val = 10;
  2. 转换成
  3. __Block_byref_val_0 val = {
  4.     0,
  5.     &val,
  6.     0,
  7.     sizeof(__Block_byref_val_0),
  8.     10
  9. };
  1. struct __Block_byref_val_0 {
  2.     void *__isa;
  3.     __Block_byref_val_0 *forwarding;
  4.     int __flags;
  5.     int __size;
  6.     int val;
  7. };
  9. struct __main_block_impl_0 {
  10.     struct __block_impl impl;
  11.     struct __main_block_desc_0 *Desc;
  12.     __Block_byref_val_0 *val;
  14.     __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,__Block_byref_val_0 *_val, int flags=0) : val(_val->__forwrding){
  15.     impl.isa = &_NSConcreteStackBlock;
  16.     impl.Flags = flags;
  17.     impl.FuncPtr = fp;
  18.     Desc = desc;
  19. }
  20. };
  22. struct void __main_block_func_0(struct __main_block_impl_0 *__cself){
  23.     __Block_byref_val_0 *val = __cself->val;
  24.     printf("val = %d",val->__forwarding->val);
  25. }

会发现一个局部变量加上__block修饰符后竟然跟block一样变成了一个__Block_byref_val_0结构体类型的自动变量实例。

此时我们在block内部访问val变量则需要通过一个叫__forwarding的成员变量来间接访问val变量。

截屏2020-06-03 下午10.22.04.png-817.9kB

如果局部变量是对象呢？

通过之前的分析，我们可以将Block修改外部变量成功的情况分为两种：
第一种：Block直接访问全局性的变量，如全局变量、静态全局变量；
第二种：Block间接访问静态局部变量，捕获外部变量并使用指针传递的方式；

Block中不允许修改外部变量的值的问题，变成了不允许修改自动变量的值的问题；但这也并非最终答案，其实最根本的原因还是Block不允许修改栈中指针的内容；

  1. - (void)viewDidLoad {
  2.     [super viewDidLoad];
  4.     Person *person = [Person new];
  5.     person.name = @"aa";
  7.     NSMutableString *name = [@"aa" mutableCopy];
  9.     square = ^(int a){
  10.         person.name = @"aaa";
  11.         [name appendString:@""];
  12.         person = [Person new];         //Variable is not assignable (missing __block type specifier)
  13.         name = [@"aaa" mutableCopy];   //Variable is not assignable (missing __block type specifier)
  14.         return 11 + a;
  15.     };
  16.     int result = square(10);
  17.     NSLog(@"%@",person.name);
  18.     NSLog(@"square %d",result);
  19. }
  21. 输出：
  22. aaa
  23. 21

https://cloud.tencent.com/developer/article/1517593

我们看如下代码C++的代码，其实变成block结构体之后，block主要做的就是一个指针拷贝，也就是栈中指针的内容不会修改，直接copy了一份指针指向对象：

  1. + (void)logResult{
  2.     Person *person1 = [[Person alloc] init];
  3.     __block Person *person2 = [[Person alloc] init];
  4.     person1.name = @"Mike";
  5.     person2.name = @"Sean";
  6.     __block int vi = 1;
  8.     void (^handler)(NSString *) = ^(NSString *name) {
  9.         person1.name = name;
  10.         person2.name = name;
  11.         vi = 2;
  12.     };
  13.     handler(@"Lucy");
  15.     NSLog(@"%@", person1.name);
  16.     NSLog(@"%@", person2.name);
  17.     NSLog(@"%i", vi);
  18. }
  19. //对应的C++的结构体
  20. struct __BlockLog__logResult_block_impl_0 {
  21.   struct __block_impl impl;
  22.   struct __BlockLog__logResult_block_desc_0* Desc;
  23.   Person *__strong person1;
  24.   __Block_byref_person2_0 *person2; // by ref
  25.   __Block_byref_vi_1 *vi; // by ref
  26.   __BlockLog__logResult_block_impl_0(void *fp, struct __BlockLog__logResult_block_desc_0 *desc, Person *__strong _person1, __Block_byref_person2_0 *_person2, __Block_byref_vi_1 *_vi, int flags=0) : person1(_person1), person2(_person2->__forwarding), vi(_vi->__forwarding) {
  27.     impl.isa = &_NSConcreteStackBlock;
  28.     impl.Flags = flags;
  29.     impl.FuncPtr = fp;
  30.     Desc = desc;
  31.   }
  32. };

为什么对于不同类型的变量，block的处理方式不同呢？

变量类型 是否捕获到block内部 访问方式
局部变量auto 是 值传递
局部变量static 是 指针传递
全局变量 否 直接访问

这是由变量的生命周期决定的。对于自动变量，当作用域结束时，会被系统自动回收，而block很可能是在超出自动变量作用域的时候去执行，如果之前没有捕获自动变量，那么后面执行的时候，自动变量已经被回收了，得不到正确的值。对于static局部变量，它的生命周期不会因为作用域结束而结束，所以block只需要捕获这个变量的地址，在执行的时候通过这个地址去获取变量的值，这样可以获得变量的最新的值。而对于全局变量，在任何位置都可以直接读取变量的值。

weak–strong dance（避免循环引用）

以上两条合起来有个名词叫weak–strong dance

以下是使用weak–strong dance的经典代码

  1. __weak __typeof(self)weakSelf = self和
  2. __strong __typeof(weakSelf)strongSelf = weakSelf
  4. //AFNetworking经典代码
  5. __weak __typeof(self)weakSelf = self;
  6. AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
  7.     __strong __typeof(weakSelf)strongSelf = weakSelf;
  8.     strongSelf.networkReachabilityStatus = status;
  9.     if (strongSelf.networkReachabilityStatusBlock) {
  10.         strongSelf.networkReachabilityStatusBlock(status);
  11.     }
  12. };

其中用到了__typeof(self)，这里涉及几个知识点：
a. __typeof、__typeof__、typeof的区别
恩~~他们没有区别，但是这牵扯一段往事，在早期C语言中没有typeof这个关键字，__typeof、__typeof__是在C语言的扩展关键字的时候出现的。
typeof是现代GNU C++的关键字，从Objective-C的根源说，他其实来自于C语言，所以AFNetworking使用了继承自C的关键字。

b.对于老的LLVM编译器上面这句话会编译报错，所以在很早的ARC使用者中流行__typeof(&*self)这种写法，原因如下
大致说法是老LLVM编译器会将__typeof转义为 XXX类名 const __strong的__strong和前面的__weak关键字对指针的修饰又冲突了，所以加上&对指针的修饰。

第四、五、六行，如果不转成strongSelf而使用weakSelf，后面几句话中，有可能在第四句执行之后self的对象可能被析构掉，然后后面的StausBlock没有执行，导致逻辑错误。

最后第五行，使用前对block判空。

 //以下代码是对__weak __typeof(self)weakSelf = self
 //和__strong __typeof(weakSelf)strongSelf = weakSelf的宏定义

  1. #ifndef weakify
  2.     #if DEBUG
  3.         #if __has_feature(objc_arc)
  4.         #define weakify(object) autoreleasepool{} __weak __typeof__(object) weak##_##object = object;
  5.         #else
  6.         #define weakify(object) autoreleasepool{} __block __typeof__(object) block##_##object = object;
  7.         #endif
  8.     #else
  9.         #if __has_feature(objc_arc)
  10.         #define weakify(object) try{} @finally{} {} __weak __typeof__(object) weak##_##object = object;
  11.         #else
  12.         #define weakify(object) try{} @finally{} {} __block __typeof__(object) block##_##object = object;
  13.         #endif
  14.     #endif
  15. #endif
  17. #ifndef strongify
  18.     #if DEBUG
  19.         #if __has_feature(objc_arc)
  20.         #define strongify(object) autoreleasepool{} __typeof__(object) object = weak##_##object;
  21.         #else
  22.         #define strongify(object) autoreleasepool{} __typeof__(object) object = block##_##object;
  23.         #endif
  24.     #else
  25.         #if __has_feature(objc_arc)
  26.         #define strongify(object) try{} @finally{} __typeof__(object) object = weak##_##object;
  27.         #else
  28.         #define strongify(object) try{} @finally{} __typeof__(object) object = block##_##object;
  29.         #endif
  30.     #endif
  31. #endif
  1. //使用方法
  2. @weakify(self);
  3. AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
  4.     @strongify(self)
  5.     if(!self)return; 
  6.     self.networkReachabilityStatus = status; 
  7.     if (self.networkReachabilityStatusBlock) {
  8.         self.networkReachabilityStatusBlock(status);
  9.     }
  10. };

Block的Copy操作

Block的存储域及copy操作

我们上面说过我们用的Block主要有以下三种类型：

这三种block各自的存储域如下图：

截屏2020-06-01 下午11.07.41.png-304.7kB

一个Block，如何确定存储位置

全局区

  1. void (^globalBlock)() = ^{
  3. };
  5. int main(int argc, const char * argv[]) {
  6.     @autoreleasepool {
  7.         void (^stackBlock)() = ^{
  9.         };
  10.         NSLog(@"%@,%@",globalBlock,stackBlock);
  11.     }
  12.     return 0;
  13. }
  1. struct __globalBlock_block_impl_0 {
  2.   struct __block_impl impl;
  3.   struct __globalBlock_block_desc_0* Desc;
  4.   __globalBlock_block_impl_0(void *fp, struct __globalBlock_block_desc_0 *desc, int flags=0) {
  5.     impl.isa = &_NSConcreteGlobalBlock;
  6.     impl.Flags = flags;
  7.     impl.FuncPtr = fp;
  8.     Desc = desc;
  9.   }
  10. };
  12. struct __main_block_impl_0 {
  13.   struct __block_impl impl;
  14.   struct __main_block_desc_0* Desc;
  15.   __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
  16.     impl.isa = &_NSConcreteStackBlock;
  17.     impl.Flags = flags;
  18.     impl.FuncPtr = fp;
  19.     Desc = desc;
  20.   }
  21. };
  1. //输出
  2. <__NSGlobalBlock__: 0x10a4d41a0>,<__NSGlobalBlock__: 0x10a4d41c0>

创建的时候stackBlock，但我们马上输出能看到它是全局区的block。

栈区->堆区

  1. int main(int argc, const char * argv[]) {
  2.     @autoreleasepool {
  3.         int a = 1;
  4.         void (^stackBlock)() = ^{
  5.             NSLog(@"%d",a);
  6.         };
  7.         NSLog(@"%@",stackBlock);
  8.     }
  9.     return 0;
  10. }
  1. //创建时是栈区block
  2. struct __main_block_impl_0 {
  3.   struct __block_impl impl;
  4.   struct __main_block_desc_0* Desc;
  5.   int a;
  6.   __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, int flags=0) : a(_a) {
  7.     impl.isa = &_NSConcreteStackBlock;
  8.     impl.Flags = flags;
  9.     impl.FuncPtr = fp;
  10.     Desc = desc;
  11.   }
  12. };
  1. //输出时是堆区block
  2. <__NSMallocBlock__: 0x600003a82f70>

创建的时候为StackBlock，然后内部引用了非全局的或静态变量，则copy了一份到堆区MallocBlock。

栈区=>全局区

  1. int main(int argc, const char * argv[]) {
  2.     @autoreleasepool {
  3.         static int a = 1;
  4.         void (^stackBlock)() = ^{
  5.             NSLog(@"%d",a);
  6.         };
  7.         NSLog(@"%@",stackBlock);
  8.     }
  9.     return 0;
  10. }
  1. //创建时为栈区
  2. struct __main_block_impl_0 {
  3.   struct __block_impl impl;
  4.   struct __main_block_desc_0* Desc;
  5.   int *a;
  6.   __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_a, int flags=0) : a(_a) {
  7.     impl.isa = &_NSConcreteStackBlock;
  8.     impl.Flags = flags;
  9.     impl.FuncPtr = fp;
  10.     Desc = desc;
  11.   }
  12. };
  1. //输出为全局区
  2. <__NSGlobalBlock__: 0x109fa51c0>

避免循环引用

为什么会发生循环引用呢？

因为对象obj在Block被copy到堆上的时候自动retain了一次。因为Block不知道obj什么时候被释放，为了不在Block使用obj前被释放，Block retain了obj一次，在Block被释放的时候，obj被release一次。

retain cycle问题的根源在于Block和obj可能会互相强引用，互相retain对方，这样就导致了retain cycle，最后这个Block和obj就变成了孤岛，谁也释放不了谁。

会发生循环引用例子的demo

使用系统的某些block api

使用系统的某些block api（如UIView的block版本写动画时），是否也考虑引用循环问题？

答案来自招聘一个靠谱的iOS第39题，个人测试了一下，感觉是有错误的，我下面代码已注释错误的地方。

系统的某些block api中，UIView的block版本写动画时不需要考虑，但也有一些api 需要考虑：

所谓“引用循环”是指双向的强引用，所以那些“单向的强引用”（block 强引用 self ）没有问题，比如这些：

  1. [UIView animateWithDuration:duration animations:^{ [self.superview layoutIfNeeded]; }]; 
  1. [[NSOperationQueue mainQueue] addOperationWithBlock:^{ self.someProperty = xyz; }]; 
  1. //会发生循环引用
  2. [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification" 
  3.             object:nil 
  4.             queue:[NSOperationQueue mainQueue]
  5.             usingBlock:^(NSNotification * notification) {
  6.                 self.someProperty = xyz; 
  7.             }];

但如果你使用一些参数中可能含有 ivar 的系统 api ，如 GCD 、NSNotificationCenter就要小心一点：比如GCD 内部如果引用了 self，而且 GCD 的其他参数是 ivar，则要考虑到循环引用，比如以下这些：

  1. //不会发生循环引用
  2. dispatch_group_async(_operationsGroup, _operationsQueue, ^
  3. {
  4.     [self doSomething];
  5.     [self doSomethingElse];
  6. } );
  8. //不会发生循环引用
  9. __weak __typeof__(self) weakSelf = self;
  10. dispatch_group_async(_operationsGroup, _operationsQueue, ^
  11. {
  12.     __typeof__(self) strongSelf = weakSelf;
  13.     [strongSelf doSomething];
  14.     [strongSelf doSomethingElse];
  15. } );
  1. //会发生循环引用
  2. [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification" 
  3.             object:nil 
  4.             queue:[NSOperationQueue mainQueue]
  5.             usingBlock:^(NSNotification * notification) {
  6.                 self.someProperty = xyz; 
  7.             }]; 
  9. //会发生循环引用
  10. _observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification" 
  11.             object:nil 
  12.             queue:[NSOperationQueue mainQueue]
  13.             usingBlock:^(NSNotification * notification) {
  14.                 self.someProperty = xyz; 
  15.             }]; 
  17. //不会发生循环引用
  18. __weak __typeof__(self) weakSelf = self;
  19. [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
  20.             object:nil
  21.             queue:nil
  22.             usingBlock:^(NSNotification *note) {
  24.             __typeof__(self) strongSelf = weakSelf;
  25.             strongSelf.someProperty = xyz; 
  26.   }];
  28. //不会发生循环引用
  29. __weak __typeof__(self) weakSelf = self;
  30. _observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
  31.             object:nil
  32.             queue:nil
  33.             usingBlock:^(NSNotification *note) {
  35.             __typeof__(self) strongSelf = weakSelf;
  36.             strongSelf.someProperty = xyz; 
  37.   }];

参考

http://www.cnblogs.com/zhangyang17/p/4667621.html
https://ioscaff.com/articles/221
Block的本质
iOS Block 详解

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注