1.1 局部变量
局部自动变量，在Block中可被读取。Block定义时copy变量的值，在Block中作为常量使用，所以即使变量的值在Block外改变，也不影响他在Block中的值，Block此时对局部变量只是做了值传递的操作。
1.2 static 修饰的全局变量
因为全局变量或静态变量在内存中的地址是固定的，Block在读取该变量值的时候是直接从其所在内存地址读出，获取到的是最新值，而不是在定义时copy的常量。
1.3 对OC对象的截获
NSMutableArray *array = [NSMutableArray array];
void(^block)() = ^(){
NSObject *obj = [[NSObject alloc] init];
[array addObject:obj];
};
block();
上述代码编译通过，Block截获的值为NSMutableArray类的对象，用C语言表述，就是用的NSMutableArray类的对象所用的结构体实例的指针，所以向该对象中添加元素操作属于使用截获变量的值，因此是没有问题的。那么对该截获的变量进行赋值
屏幕快照 2016-06-23 下午2.12.28.png
编译未通过，提示缺少__block修饰符。
1.4 C语言数组
屏幕快照 2016-06-23 下午2.18.28.png
上图代码中, 在Block外部定义一个C语言字符串字面量数组, 在Block内部截获自动变量的方法并没有实现对C语言数组的截获, 此时访问数组元素text[2]会报错. 此时使用指针可以解决.
const char *text = "adsdczv";
void(^block)() = ^(){
NSLog(@"%c",text[2]);
};
block();
1.5__block 修饰的变量
某些场景下，我们需要在Block内部对外部变量进行修改。这时需要使用__block来修饰该变量实现在Block内部的修改，此时Block是复制其引用地址来实现访问的。
关于__block 修饰符
从上面讲解我们已经知道，Block内部能够读取外部局部变量的值。但如果我们需要在Block内部修改变量的值，则需要在Block外部给该变量添加一个__block修饰符。
__block另一个使用场景是，避免某些情况下Block使用中出现的循环引用的问题，此时可以给相应的对象加上一个__block来修饰。
为什么使用__block可以实现在Block内部修改外部变量的值？
这边我们用一个Block代码，并使用clang _rewrite_objc命令转换成C++的代码来说明__block是怎么实现内部变量的修改。
Block在main中实现
int main(int argc, const char * argv[]) {
@autoreleasepool {
NSInteger val = 10;
void (^block)(void) = ^{
NSLog(@"%ld", val);
};
block();
}
return 0;
}
转码后：
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
int val;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _val, int flags=0) : val(_val) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
int val = __cself->val; // bound by copy
NSLog((NSString *)&__NSConstantStringImpl__val_folders_gm_0jk35cwn1d3326x0061qym280000gn_T_main_41daf1_mi_0, val);
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
int val = 10;
void (*block)(void) = (void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, val);
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
}
return 0;
}
从展开代码可以发现，Block被转成了一个struct __main_block_impl_0类型的结构体实例，并且该结构体成员中包含局部变量val。当执行Block时，通过该实例找到Block执行部分void __main_block_func_0，并把该结构体实例传入到void __main_block_func_0方法中。
void __main_block_func_0方法中第一个参数声明如下
struct __main_block_impl_0 *__cself
注意：这里的__cself就类似于OC中的self,而它指向结构体的指针。
此时我们就可以通过__cself->val访问该局部变量。
那么问题来了，为什么此时不对变量val进行修改？
因为main函数中的局部变量val和函数__main_block_func_0不在同一个作用域中，调用过程中只是进行了值传递。
当然，在上面代码中，我们可以通过指针来实现局部变量的修改。不过这是由于在调用__main_block_func_0时，main函数栈还没展开完成，变量val还在栈中。
但是在很多情况下，Block是作为参数传递以供后续回调执行的。通常在这些情况下，Block被执行时，定义时所在的函数栈已经被展开，局部变量已经不在栈中了，再用指针访问会产生野指针错误。
所以，这类情况下对于auto类型的局部变量，不允许Block进行修改是合理的。
__block是如何实现变量修改的
此时使用更新后的代码
添加__block修饰符后
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block NSInteger val = 0;
void (^block)(void) = ^{
val = 1;
};
block();
NSLog(@"val = %ld", val);
}
return 0;
}
使用_rewrite_objc展开
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
NSInteger val;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_val_0 *val; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;
}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);}
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*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(int argc, const char * argv[]) {
/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
__attribute__((__blocks__(byref))) __Block_byref_val_0 val = {(void*)0,(__Block_byref_val_0 *)&val, 0, sizeof(__Block_byref_val_0), 0};
void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_val_0 *)&val, 570425344));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
NSLog((NSString *)&__NSConstantStringImpl__var_folders_2h_70k4gzp53qn7ytk0cdjr9kk80000gn_T_main_7eb9e7_mi_0,(val.__forwarding->val));
}
return 0;
｝
这次转码后似乎比刚才多了些东西，仔细看下，
一个是__Block_byref_val_0的结构体以及两个方法static void __main_block_copy_0和static void __main_block_dispose_0; 后面的两个方法先暂且不关注（后面会涉及）。
其实结构体__Block_byref_val_0产生的实例就是我们使用__block修饰过的变量。
struct __Block_byref_val_0 {
void *__isa;
__Block_byref_val_0 *__forwarding;
int __flags;
int __size;
NSInteger val;
};
从该结构体声明可以看出，这个结构体中包含了该实例本身的引用 __forwarding。
我们从上述被转化的代码中可以看出 Block 本身也一样被转换成了__main_block_impl_0结构体实例，该实例持有__Block_byref_val_0结构体实例的指针。
我们再看一下Block实现和调用部分代码被转化后的结果：
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
__Block_byref_val_0 *val = __cself->val; // bound by ref
(val->__forwarding->val) = 1;
}
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
不难发现从__cself找到__Block_byref_val_0结构体实例，然后通过该实例的__forwarding访问成员变量val。成员变量val是该实例自身持有的变量，指向的是原来的局部变量。
详情参见下图：
__block.jpg
至此，已经展示了__block变量在Block中查找和修改的过程，那么：
当Block作为回调执行时，局部变量val已经出栈了，这个时候代码为什么还能正常工作呢?
我们为什么通过成员变量__forwarding而不是直接去访问结构体中我们需要修改的变量呢?
我们在上述转换过的代码中可以发现__main_block_impl_0结构体构造函数中，isa指针指向的是_NSConcreteStackBlock; 而Block还有另外两个与之相似的类：
_NSConcreteGlobalBlock //全局的静态block 不会访问任何外部变量
_NSConcreteMallocBlock //保存在堆区的，引用计数为0时会被销毁。
_NSConcreteStackBlock //保存在栈区，出栈后被销毁
上述示例代码中，Block是被设为_NSConcreteStackBlock，在栈上生成。当我们把Block作为全局变量使用时，对应生成的Block将被设为_NSConcreteGlobalBlock
void (^block)(void) = ^{NSLog(@"This is a Global Block");};
int main(int argc, const char * argv[]) {
@autoreleasepool {
block();
}
return 0;
}
该代码转码c++后，Block结构体的isa指针初始化时如下:
impl.isa = &_NSConcreteGlobalBlock；
那_NSConcreteMallocBlock何时被使用
分配在全局变量上的Block，在变量作用域外也可以通过指针安全的访问。
但分配在栈上的Block，如果它所属的变量作用域结束，该Block就被废弃。同样，__block变量也分配在栈上，当超过该变量的作用域时，该__block变量也会被废弃。
此时，就需要使用_NSConcreteMallocBlock，OC中提供了将Block和__block变量从栈上复制到堆上的方法，将分配到栈上的Block复制到堆上，这样当栈上的Block超过它原本作用域时，堆上的Block还可以继续存在。
复制到堆上的Block，它的结构体成员变量isa将变为：
impl.isa = &_NSConcreteMallocBlock；
而_block变量中结构体成员__forwarding就在此时保证了从栈上复制到堆上能够正确访问__block变量。在这种情况下，只要栈上的_block变量的成员变量__forwarding指向堆上的实例，我们就能够正确访问。
我们一般可以使用copy方法手动将 Block 或者 __block变量从栈复制到堆上。比如我们把Block做为类的属性访问时，我们一般把该属性设为copy。有些情况下我们可以不用手动复制,比如Cocoa框架中使用含有usingBlock方法名的方法时，或者GCD的API中传递Block时。
当一个Block从栈复制到堆中，与之相关的__block变量也会被复制到堆中。此时堆中的Block持有相应堆上的__block变量，当堆上的__block变量没有持有者，才会被释放。
而在栈上的__block变量被复制到堆上之后，会将成员变量__forwarding的值替换为堆上的__block变量的地址。这个时候我们可以通过以下代码访问:
val.__forwarding->val
如下图：
__block变量和循环引用问题
__block修饰符可以指定任意类型的局部变量。此时还记这两个方法吗？
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src { _Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/); } static void __main_block_dispose_0(struct __main_block_impl_0*src) { _Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/); }
当Block从栈复制到堆时，会调用_Block_object_assign函数持有该变量(相当于retain);
当堆上的Block被废弃时，会调用_Block_object_dispose函数释放该变量(相当于release)。
由上文描述可知，我们可以使用下述代码解除Block循环引用的问题:
__block id tmp = self;
void(^block)(void) = ^{
tmp = nil;
};
block();
通过执行block方法，nil被赋值到_block变量tmp中。这个时候_block变量对 self 的强引用失效，从而避免循环引用的问题。
总结：
通过__block变量可以控制对象的生命周期，在不能使用__weak修饰符的环境中，我们可以避免使用__unsafe_unretained修饰符。
在执行Block时可动态地决定是否将nil或者其它对象赋值给__block变量。
但是这种方法有一个明显的缺点就是，我们必须去执行Block才能够解除循环引用问题，否则就会出现问题。
4. 比较__weak 和 __strong
这边用AFN中的一段代码
__weak __typeof(self)weakSelf = self;
AFNetworkReachabilityStatusBlock callback = ^(AFNetworkReachabilityStatus status) {
__strong __typeof(weakSelf)strongSelf = weakSelf;
strongSelf.networkReachabilityStatus = status;
if (strongSelf.networkReachabilityStatusBlock) {
strongSelf.networkReachabilityStatusBlock(status);
}
};
1. __weak
我们在使用Block时，有时候会用到self，而Block内部对self默认都是强引用。在ARC下，编译器将Block从栈区拷贝到堆区，Block会强引用和持有self，而self 也会强引用和持有Block，于是就造成了循环引用。
此时就需要使用__weak，在修饰变量时，修饰符修饰变量self，让 block 不强引用self，从而破除循环。
__weak typeof(self) weakSelf = self;
self.passValueBlock = ^(NSString *string){
dispatch_async(dispatch_get_main_queue(), ^{
weakSelf.pointView.startLabel.text = string;
});
};
弱引用不会影响对象释放，当一个对象被释放是，所有指向它的弱引用会被置空，也避免出现野指针。
2. __strong
上面提到，__weak很好的解决retain Cycle，但还是会存在一些隐患。不知道self什么时候被释放，为了保证在Block内部不会被释放，所以使用__strong修饰。
看下一段测试代码
在ViewController添加属性
@property (nonatomic, strong) ViewController *vc;
viewDidLoad中
ViewController *vc = [[ViewController alloc] init];
self.vc = vc;
__weak ViewController * weakVC = self.vc;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSInteger count = 0;
while (count < 4) {
count++;
NSLog(@"%@",weakVC);
sleep(1);
}
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
self.vc = nil;
});
实现dealloc方法
- (void)dealloc {
NSLog(@"%@",[self class]);
}
看输出结果：
2016-06-20 15:12:27.797 __strongTest[14823:1753981]
2016-06-20 15:12:28.802 __strongTest[14823:1753981]
2016-06-20 15:12:29.797 __strongTest[14823:1753934] ViewController
2016-06-20 15:12:29.804 __strongTest[14823:1753981] (null)
2016-06-20 15:12:30.808 __strongTest[14823:1753981] (null)
可以看出：Block内部的对self.vc是弱引用。当2s后，self.vc在外部被释放，则Block内部对self.vc的持有也失效。
现在在Block内部对self.vc进行强引用，Block内部代码调整为：
__strong ViewController *strongVC = weakVC;
NSInteger count = 0;
while (count < 4)
count++;
NSLog(@"%@",strongVC);
sleep(1);
}
再看输出结果：
2016-06-20 15:22:38.423 __strongTest[14839:1762881]
2016-06-20 15:22:39.424 __strongTest[14839:1762881]
2016-06-20 15:22:40.429 __strongTest[14839:1762881]
2016-06-20 15:22:41.430 __strongTest[14839:1762881]
2016-06-20 15:22:42.431 __strongTest[14839:1762835] ViewController
Block内部对对象采用strong修饰后，既使原持有对象在block外部已经被释放，但Block内部扔能持有，于是执行完Block后，该对象才被dealloc。
总结：weakSelf是为了Block不持有self，避免循环引用，而再声明一个strongSelf是因为一旦进入Block执行，就不允许self在这个执行过程中释放。Block执行完后这个strongSelf会自动释放，没有循环引用问题。
最后，使用Block时的注意事项
1.Block内部不能直接修改局部变量
Block内部可以访问外部的变量, 默认是将其拷贝到其数据结构中来实现访问的, 属性是只读的. Block内部不能修改外面的局部变量.
如果要修改需要对要修改的局部变量用__block修饰, 这样局部变量就可以在Block内部修改了，Block是复制其引用地址来实现访问的
2.当Block里面的出现self,造成的循环引用
循环引用就是当self 拥有一个Block的时候，在Block中又调用self的方法。形成了你中有我，我中有你，造成谁都无法将谁释放。从而发生内存泄漏。
解决方法:
__weak typeof (self) weakSelf = self;
定义一个weakSelf变量并加上__weak修饰符，在Block代码块中，所有需要self的地方都用weakSelf来替代。这样就不会增加引用计数，所以Block持有self对象也就不会造成循环引用，从而避免内存泄漏。
参考
Objective-C 高级编程: iOS和OS X多线程和内存管理
