block 对外部引用变量的处理

MRC 环境

一、静态变量和全局变量在加和不加 block 都会直接引用变量地址。也就意味着可以修改变量的值。在没有加block 参数的情况下。

全局block 和栈block 区别为是否引用了外部变量，堆block 则是对栈block copy 得来。对全局block copy 不会有任何作用,返回的依然是全局block。

二，常量变量（NSString *a = @"hello";a 为常量变量，@“hello”为常量。）-----不加block类型 block 会引用常量的地址（浅拷贝）。加block类型 block会去引用常量变量（如：a变量，a = @"abc".可以任意修改a 指向的内容。）的地址。

如果不加__block 直接在block 内部修改变量，会编译报错。block 内部改变量是只读的。

但是就一定可以推断 block 会深拷贝该变量吗？？？

对于常量 @“hello” 存储在内存中的常量区，程序结束才会释放内存。如：

NSString *str = @"hello";

NSString *abcStr = @"hello";

编译器会优化处理， str 和 abcStr 都会指向常量区的@“hello” 地址。

    NSString *str = @"hello";

    void (^print)(void) = ^{

        NSLog(@"block=str======%p",str);

    }

     str = @"hello1";

    print();

block 会拷贝变量内容到自己的栈内存上，以便执行时可以调用。但并不是对str 内容做了深拷贝，重新申请内存。

因为str 是栈内存上的变量，指向一个常量区的@“hello”. 编译器做的优化是当block 去拷贝str 指向内容时发现是个常量，

所以会去引用 @“hello” 的指针，没必要再取申请一块内存。

三、对象变量如（MyClass *class、Block block）。这里block 也是”类“对象（类似对象，其包含isa指针,clang 反编译可以查看。因为它不像从NSObject 继承下来的对象都支持 retain、copy、release）。

下面直接引用文章里总结的，经验证无误。

Block的copy、retain、release操作

不同于NSObjec的copy、retain、release操作：

Block_copy与copy等效，Block_release与release等效；
对Block不管是retain、copy、release都不会改变引用计数retainCount，retainCount始终是1；
NSGlobalBlock：retain、copy、release操作都无效；
NSStackBlock：retain、release操作无效，必须注意的是，NSStackBlock在函数返回后，Block内存将被回收。即使retain也没用。容易犯的错误是[[mutableAarry addObject:stackBlock]，在函数出栈后，从mutableAarry中取到的stackBlock已经被回收，变成了野指针。正确的做法是先将stackBlock copy到堆上，然后加入数组：[mutableAarry addObject:[[stackBlock copy] autorelease]]。支持copy，copy之后生成新的NSMallocBlock类型对象。
NSMallocBlock支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数。copy之后不会生成新的对象，只是增加了一次引用，类似retain；
尽量不要对Block使用retain操作。

文章链接：http://tanqisen.github.io/blog/2013/04/19/gcd-block-cycle-retain/

以下补充

栈block : 猜测》》》》会copy 内部引用的对象变量。(如何验证 block copy 了外部变量......在block 执行前释放对象.)。

但实际对两种对象变量的操作为：

MyClass *class : 栈block 并不会copy 对象变量,也不会retain 对象。而是直接引用了对象变量的地址。可以在blcok 执行前释放对象验证。（有点毁三观啊）
Block block （ ”类“对象）：不会对 block 做处理。如果block 是栈block ，执行时依然为栈block. 堆block 同理

堆block : 通过copy 栈block 获得，当向栈block copy 时。会对内部引用的对象变量如下处理。

MyClass *class ： block 会retain 内部引用的对象变量，改变引用对象的内存计数。
Block block（ ”类“对象）： ”类“对象block 执行copy ，如果是栈block。如果为堆block 并不会对他copy 。

GCD block :会对内部引用的对象变量如下处理。

MyClass *class： retain 内部引用的对象变量，改变引用对象的内存计数。
Block block（ ”类“对象）： ”类“对象block 执行copy 。

    dispatch_async(dispatch_get_main_queue(), ^{

    });

当然如果引用了外部栈block 变量，也会copy 栈block 到堆上。同时栈block 对其内部引用对象变量重复前面的操作。

这里不如说 GCD 里的 block是内部做了处理的堆block 。

以上结论均在 MRC 环境的 viewDidLoad 方法中测试。

ARC环境下

虽然 ARC 环境下会对栈block 做优化，当创建一个栈block 时默认返回一个堆block 。但并不是ARC 环境下没有栈block 。

如

-(void)demo:(Block)blocka;

-(void)demo:(Block)blocka{

NSLog(@"==demo=====%@",blocka);

}

通过方法参数传递的 block 就是栈block。

由此引出 block 循环引用问题：

循环引用成立的条件：直接导致A B 两个对象相互强引用（retain,strong）、或者间接导致 A B 两个对象相互强引用。

直接循环引用：

ARC 环境。

ARC 中 LLVM 会监控对象引用情况，如果出现循环引用会waring.

第一个警告是间接循环引用。

ViewController -----retain--> Custom
Custom -------强引用--->CustomBlock(堆block,会retain 内部引用对象变量)
CustomBlock ---retain--------->self(ViewController)

第二个警告直接循环引用。

ViewController --强引用------>Block(堆block,会retain 内部引用对象变量)
Block------retain--------->self(ViewController)

对于第三个我们常用的GCD block 中，则没有出现警告。虽然 gcd block 同样对self 进行了retain.

  dispatch_async(dispatch_get_main_queue(), ^{

        NSLog(@"====%@",self);

    });

但是self 并没有直接或间接的去强引用 gcd block。可以想象 gcd block 会统一被管理在GcdBlockDispatchCenter(这个是我瞎扯的，相当于GCD block 调度中心来管理，反正不是self 。)。

还有一种情况下不会出现循环引用如： ARC 环境

2014-12-30 11:05:59.119 Test_Class[4235:230795] ==demo=====<__NSStackBlock__: 0x118600>

上面说到，栈block 并不会对内部引用对象变量 retain .而是直接引用对象变量地址。、、

这里 self 和 Custom 并没有对方法参数blocka 做任何引用操作，blocka 一直存在于栈上，直到执行完毕被释放掉。
当然blocka 也没有对self 做任何操作，直接引用了地址。

以上也就是说只有堆block 才会存在循环引用的情况。

》》待续.....

复习下内存分类： http://blog.csdn.net/u011848617/article/details/39346075