iOS里关于block的一些理解
介绍
block实际上就是Objective-C语言对于闭包的实现。
block配合上dispatch_queue，可以方便地实现简单的多线程编程和异步编程。
（闭包是一个函数（或指向函数的指针），再加上该函数执行的外部的上下文变量（有时候也称作自由变量）。）
block的写法
回传值(^名字)(参数列);
// 声明一个square的Block Pointer，其所指向的Block有一个int输入和int输出
typedef int (^square)(int);
// 将Block实体指定给square
square = ^(int a){ return a * a; };
// 调用方法，感觉是是不是很像function的用法？
int result = square(5);
NSLog(@"%d", result); 当其作为Object-C method的传入值的话，需要把类型写在变量前面，然后加上小括号。比如下面这种写法：
// square参数的类型是int(^)(int)
-(void)objcMethod:(int(^)(int))square; block阵列的使用
{
void (^blocks[3])(void);
for (NSInteger i = 0; i < 3; i++) {
blocks[i] = ^{
NSLog(@"Hello:%i", i);
};
}
blocks[0](); // result:Hello:0
blocks[1](); // result:Hello:1
blocks[2](); // result:Hello:2
}存取变量
Block将使用到的、作用域附近的变量的值建立一份快照拷贝到栈上。
- 读取和Block pointer同一个Scope的变量值：
{
int outA = 8;
int (^myPtr)(int) = ^(int a){ return outA + a;};
//block里面可以读取同一类型的outA的值
int result = myPtr(3); // result is 11
NSLog(@"result=%d", result);
}下面这一段代码就不一样了
{
int outA = 8;
int (^myPtr)(int) = ^(int a){ return outA + a;};//block里面可以读取同一类型的outA的值
outA = 5; // 在调用myPtr之前改变outA的值
int result = myPtr(3); // result的值仍然是11，并不是8
NSLog(@"result=%d", result);
} 为什么result 的值仍然是11？而不是8呢？事实上，myPtr在其主体中用到的outA这个变量值的时候做了一个copy的动作，把outA的值copy下来，在Block中作为常量使用。所以，之后outA即使换成了新的值，对于myPtr里面copy的值是没有影响的。（类似于深拷贝）
需要注意的是，这里copy的值是变量的值，如果它是一个记忆体的位置（地址），换句话说，就是这个变量是个指针的话，它的值是可以在block里被改变的。(相当于浅拷贝，拷贝的只是一个指针地址，对象地址还是没变的)
{
NSMutableArray \*mutableArray = [NSMutableArray arrayWithObjects:@"one", @"two", @"three", nil];
int result = ^(int a){[mutableArray removeLastObject]; return a*a;}(5);
NSLog(@"test array :%@", mutableArray);
}
// 原本mutableArray的值是{@"one",@"two",@"three"}，在block里面被更改mutableArray后，就变成{@"one", @"two"}了。- 直接存取static类型的变量
因为全局变量或静态变量在内存中的地址是固定的，Block在读取该变量值的时候是直接从其所在内存读出，获取到的是最新值，而不是在定义时copy的常量。
{
static int outA = 8;
int (^myPtr)(int) = ^(int a){return outA + a;};
outA = 5;
int result = myPtr(3);
//result的值是8，因为outA是static类型的变量 (该变量在全局数据区分配内存,但作用域还是局部作用域)
NSLog(@"result=%d", result);
} - Block Variable类型的变量
在某个变量前面如果加上修饰字“__block”的话（注意，block前面有两个下划线），这个变量就称作block variable。基本类型的Block变量等效于全局变量、或静态变量。即将“外部变量”在栈中的内存地址放到了堆中。
那么在block里面就可以任意修改此变量的值，如下代码：
{
__block int num = 5;
NSLog(@"定义前：%p", &num);
int (^myPtr)(int) = ^(int a){
NSLog(@"block内部：%p", &num);
return num++; };
int (^myPtr2)(int) = ^(int a){
NSLog(@"block内部：%p", &num);
return num++;
};
int result = myPtr(0); //result的值为5，num的值为6
result = myPtr2(0); //result的值为6，num的值为7
NSLog(@"定义后：%p", &num);
NSLog(@"result=%d", result);
}输出（我们看到num进入block之后内存地址其实改变了，也就是block 内部的变量会被 copy 到堆区）：
2016-09-12 16:24:16.622 test[20146:972930] 定义前：0x7fff5caf0a78
2016-09-12 16:24:16.623 test[20146:972930] block内部：0x7ff539c0b1a8
2016-09-12 16:24:16.623 test[20146:972930] block内部：0x7ff539c0b1a8
2016-09-12 16:24:16.623 test[20146:972930] 定义后：0x7ff539c0b1a8
2016-09-12 16:24:16.623 test[20146:972930] result=6
- weak–strong dance（避免循环引用）
使用方将self或成员变量加入block之前要先将self变为__weak
在多线程环境下（block中的weakSelf有可能被析构的情况下），需要先将self转为strong指针，避免在运行到某个关键步骤时self对象被析构。
以上两条合起来有个名词叫weak–strong dance
以下是使用weak–strong dance的经典代码
__weak __typeof(self)weakSelf = self和
__strong __typeof(weakSelf)strongSelf = weakSelf
// AFNetworking经典代码
__weak __typeof(self)weakSelf = self;
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
__strong __typeof(weakSelf)strongSelf = weakSelf;
strongSelf.networkReachabilityStatus = status;
if (strongSelf.networkReachabilityStatusBlock) {
strongSelf.networkReachabilityStatusBlock(status);
}
};其中用到了__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的宏定义
#ifndef weakify
#if DEBUG
#if __has_feature(objc_arc)
#define weakify(object) autoreleasepool{} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) autoreleasepool{} __block __typeof__(object) block##_##object = object;
#endif
#else
#if __has_feature(objc_arc)
#define weakify(object) try{} @finally{} {} __weak __typeof__(object) weak##_##object = object;
#else
#define weakify(object) try{} @finally{} {} __block __typeof__(object) block##_##object = object;
#endif
#endif
#endif
#ifndef strongify
#if DEBUG
#if __has_feature(objc_arc)
#define strongify(object) autoreleasepool{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) autoreleasepool{} __typeof__(object) object = block##_##object;
#endif
#else
#if __has_feature(objc_arc)
#define strongify(object) try{} @finally{} __typeof__(object) object = weak##_##object;
#else
#define strongify(object) try{} @finally{} __typeof__(object) object = block##_##object;
#endif
#endif
#endif// 使用方法
@weakify(self);
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
@strongify(self)
if(!self)return;
self.networkReachabilityStatus = status;
if (self.networkReachabilityStatusBlock) {
self.networkReachabilityStatusBlock(status);
}
};避免循环引用
为什么会发生循环引用呢？
因为对象obj在Block被copy到堆上的时候自动retain了一次。因为Block不知道obj什么时候被释放，为了不在Block使用obj前被释放，Block retain了obj一次，在Block被释放的时候，obj被release一次。
retain cycle问题的根源在于Block和obj可能会互相强引用，互相retain对方，这样就导致了retain cycle，最后这个Block和obj就变成了孤岛，谁也释放不了谁。
使用系统的某些block api
使用系统的某些block api（如UIView的block版本写动画时），是否也考虑引用循环问题？
答案来自招聘一个靠谱的iOS第39题，个人测试了一下，感觉是有错误的，我下面代码已注释错误的地方。
系统的某些block api中，UIView的block版本写动画时不需要考虑，但也有一些api 需要考虑：
所谓“引用循环”是指双向的强引用，所以那些“单向的强引用”（block 强引用 self ）没有问题，比如这些：
[UIView animateWithDuration:duration animations:^{ [self.superview layoutIfNeeded]; }];[[NSOperationQueue mainQueue] addOperationWithBlock:^{ self.someProperty = xyz; }]; // 会发生循环引用
[[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
object:nil
queue:[NSOperationQueue mainQueue]
usingBlock:^(NSNotification * notification) {
self.someProperty = xyz;
}]; 但如果你使用一些参数中可能含有 ivar 的系统 api ，如 GCD 、NSNotificationCenter就要小心一点：比如GCD 内部如果引用了 self，而且 GCD 的其他参数是 ivar，则要考虑到循环引用，比如以下这些：
// 不会发生循环引用
dispatch_group_async(_operationsGroup, _operationsQueue, ^
{
[self doSomething];
[self doSomethingElse];
} );
// 不会发生循环引用
__weak __typeof__(self) weakSelf = self;
dispatch_group_async(_operationsGroup, _operationsQueue, ^
{
__typeof__(self) strongSelf = weakSelf;
[strongSelf doSomething];
[strongSelf doSomethingElse];
} );
// 会发生循环引用
[[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
object:nil
queue:[NSOperationQueue mainQueue]
usingBlock:^(NSNotification * notification) {
self.someProperty = xyz;
}];
// 会发生循环引用
_observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
object:nil
queue:[NSOperationQueue mainQueue]
usingBlock:^(NSNotification * notification) {
self.someProperty = xyz;
}];
// 不会发生循环引用
__weak __typeof__(self) weakSelf = self;
[[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
object:nil
queue:nil
usingBlock:^(NSNotification *note) {
__typeof__(self) strongSelf = weakSelf;
strongSelf.someProperty = xyz;
}];
// 不会发生循环引用
__weak __typeof__(self) weakSelf = self;
_observer = [[NSNotificationCenter defaultCenter] addObserverForName:@"someNotification"
object:nil
queue:nil
usingBlock:^(NSNotification *note) {
__typeof__(self) strongSelf = weakSelf;
strongSelf.someProperty = xyz;
}];