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

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. };
  7. static struct __ViewController__viewDidLoad_block_desc_0 {
  8. size_t reserved;
  9. size_t Block_size;
  10. }
  11. struct __ViewController__viewDidLoad_block_impl_0 {
  12. struct __block_impl impl;
  13. struct __ViewController__viewDidLoad_block_desc_0* Desc;
  14. int b;
  15. __ViewController__viewDidLoad_block_impl_0(void *fp, struct __ViewController__viewDidLoad_block_desc_0 *desc, int _b, int flags=0) : b(_b) {
  16. impl.isa = &_NSConcreteStackBlock;
  17. impl.Flags = flags;
  18. impl.FuncPtr = fp;
  19. Desc = desc;
  20. }
  21. };

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

改为局部静态变量

我们把上面的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;
  2. int (*block)(int) = &__main_block_impl_0(__main_block_func_0, &__main_block_desc_0_DATA, outA);
  3. outA = 5;
  4. 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. }
  6. //原本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++; };
  7. int (^myPtr2)(int) = ^(int a){
  8. NSLog(@"block内部:%p", &num);
  9. return num++;
  10. };
  11. int result = myPtr(0); //result的值为5,num的值为6
  12. result = myPtr2(0); //result的值为6,num的值为7
  13. NSLog(@"定义后:%p", &num);
  14. NSLog(@"result=%d", result);
  15. }

输出(我们看到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. };
  8. struct __main_block_impl_0 {
  9. struct __block_impl impl;
  10. struct __main_block_desc_0 *Desc;
  11. __Block_byref_val_0 *val;
  12. __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc,__Block_byref_val_0 *_val, int flags=0) : val(_val->__forwrding){
  13. impl.isa = &_NSConcreteStackBlock;
  14. impl.Flags = flags;
  15. impl.FuncPtr = fp;
  16. Desc = desc;
  17. }
  18. };
  19. struct void __main_block_func_0(struct __main_block_impl_0 *__cself){
  20. __Block_byref_val_0 *val = __cself->val;
  21. printf("val = %d",val->__forwarding->val);
  22. }

会发现一个局部变量加上__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];
  3. Person *person = [Person new];
  4. person.name = @"aa";
  5. NSMutableString *name = [@"aa" mutableCopy];
  6. square = ^(int a){
  7. person.name = @"aaa";
  8. [name appendString:@""];
  9. person = [Person new]; //Variable is not assignable (missing __block type specifier)
  10. name = [@"aaa" mutableCopy]; //Variable is not assignable (missing __block type specifier)
  11. return 11 + a;
  12. };
  13. int result = square(10);
  14. NSLog(@"%@",person.name);
  15. NSLog(@"square %d",result);
  16. }
  17. 输出:
  18. aaa
  19. 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;
  7. void (^handler)(NSString *) = ^(NSString *name) {
  8. person1.name = name;
  9. person2.name = name;
  10. vi = 2;
  11. };
  12. handler(@"Lucy");
  13. NSLog(@"%@", person1.name);
  14. NSLog(@"%@", person2.name);
  15. NSLog(@"%i", vi);
  16. }
  17. //对应的C++的结构体
  18. struct __BlockLog__logResult_block_impl_0 {
  19. struct __block_impl impl;
  20. struct __BlockLog__logResult_block_desc_0* Desc;
  21. Person *__strong person1;
  22. __Block_byref_person2_0 *person2; // by ref
  23. __Block_byref_vi_1 *vi; // by ref
  24. __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) {
  25. impl.isa = &_NSConcreteStackBlock;
  26. impl.Flags = flags;
  27. impl.FuncPtr = fp;
  28. Desc = desc;
  29. }
  30. };

为什么对于不同类型的变量,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
  3. //AFNetworking经典代码
  4. __weak __typeof(self)weakSelf = self;
  5. AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
  6. __strong __typeof(weakSelf)strongSelf = weakSelf;
  7. strongSelf.networkReachabilityStatus = status;
  8. if (strongSelf.networkReachabilityStatusBlock) {
  9. strongSelf.networkReachabilityStatusBlock(status);
  10. }
  11. };

其中用到了__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
  16. #ifndef strongify
  17.     #if DEBUG
  18.         #if __has_feature(objc_arc)
  19.         #define strongify(object) autoreleasepool{} __typeof__(object) object = weak##_##object;
  20.         #else
  21.         #define strongify(object) autoreleasepool{} __typeof__(object) object = block##_##object;
  22.         #endif
  23.     #else
  24.         #if __has_feature(objc_arc)
  25.         #define strongify(object) try{} @finally{} __typeof__(object) object = weak##_##object;
  26.         #else
  27.         #define strongify(object) try{} @finally{} __typeof__(object) object = block##_##object;
  28.         #endif
  29.     #endif
  30. #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)() = ^{
  2. };
  3. int main(int argc, const char * argv[]) {
  4. @autoreleasepool {
  5. void (^stackBlock)() = ^{
  6. };
  7. NSLog(@"%@,%@",globalBlock,stackBlock);
  8. }
  9. return 0;
  10. }
  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. };
  11. struct __main_block_impl_0 {
  12. struct __block_impl impl;
  13. struct __main_block_desc_0* Desc;
  14. __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
  15. impl.isa = &_NSConcreteStackBlock;
  16. impl.Flags = flags;
  17. impl.FuncPtr = fp;
  18. Desc = desc;
  19. }
  20. };
  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. } );
  7. //不会发生循环引用
  8. __weak __typeof__(self) weakSelf = self;
  9. dispatch_group_async(_operationsGroup, _operationsQueue, ^
  10. {
  11. __typeof__(self) strongSelf = weakSelf;
  12. [strongSelf doSomething];
  13. [strongSelf doSomethingElse];
  14. } );
  1. //会发生循环引用
  2. [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
  3. object:nil
  4. queue:[NSOperationQueue mainQueue]
  5. usingBlock:^(NSNotification * notification) {
  6. self.someProperty = xyz;
  7. }];
  8. //会发生循环引用
  9. _observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
  10. object:nil
  11. queue:[NSOperationQueue mainQueue]
  12. usingBlock:^(NSNotification * notification) {
  13. self.someProperty = xyz;
  14. }];
  15. //不会发生循环引用
  16. __weak __typeof__(self) weakSelf = self;
  17. [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
  18. object:nil
  19. queue:nil
  20. usingBlock:^(NSNotification *note) {
  21. __typeof__(self) strongSelf = weakSelf;
  22. strongSelf.someProperty = xyz;
  23. }];
  24. //不会发生循环引用
  25. __weak __typeof__(self) weakSelf = self;
  26. _observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
  27. object:nil
  28. queue:nil
  29. usingBlock:^(NSNotification *note) {
  30. __typeof__(self) strongSelf = weakSelf;
  31. strongSelf.someProperty = xyz;
  32. }];

参考

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

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