介绍
block实际上就是Objective-C语言对于闭包的实现。
block配合上dispatch_queue，可以方便地实现简单的多线程编程和异步编程。
（闭包是一个函数（或指向函数的指针），再加上该函数执行的外部的上下文变量（有时候也称作自由变量）。）
block的写法
回传值(^名字)(参数列);
//声明一个square的Block Pointer，其所指向的Block有一个int输入和int输出
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将使用到的、作用域附近的变量的值建立一份快照拷贝到栈上。
1、读取和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"}了。
2、直接存取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);
}
3、Block Variable类型的变量
在某个变量前面如果加上修饰字“__block”的话（注意，block前面有两个下划线），这个变量就称作block variable。基本类型的Block变量等效于全局变量、或静态变量。
那么在block里面就可以任意修改此变量的值，如下代码：
{
__block int num = 5;
int (^myPtr)(int) = ^(int a){return num++;};
int (^myPtr2)(int) = ^(int a){return num++;};
int result = myPtr(0); //result的值为5，num的值为6
result = myPtr2(0); //result的值为6，num的值为7
NSLog(@"result=%d", result);
}
4、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就变成了孤岛，谁也释放不了谁。
