Block 再次研究 - 循环引用

1 使用
2 循环引用
循环引用 - 实测举例：

1 使用

以下仅做举例，也只贴关键代码；

1 回调传出参数

// 声明属性 copy，block作为类似实例
@property (nonatomic, copy) void(^outputBlock)(NSString *title);

// button 点击事件传出，内容
- (void)button1Action:(UIButton *)button {
    if (self.outputBlock) {
        self.outputBlock(@"输出");
    }
}

// 外部调用，获得block 传出的参数
    [testView setOutputBlock:^(NSString *title) {
        NSLog(@"%@",title);
    }];

2 作为实例，传入参数

@property (nonatomic, copy) UIColor *(^inputBlock)();

// 点击事件，触发block的同时，还获取了block传入的color参数
- (void)button2Action:(UIButton *)button {
    if (self.inputBlock) {
        button.backgroundColor =  self.inputBlock();
    }
}

// 外部调用，block 传入的参数，供触发block处使用
    [testView setInputBlock:^UIColor *{
        return [UIColor blueColor];
    }];

3 上面二合一，即传入，又传出，（仅做举例，并不是很合理的方案）

@property (nonatomic, copy) NSString *(^doubleBlock)(UIButton *button, NSString *title);


    [testView setDoubleBlock:^NSString *(UIButton *button, NSString *title) {
        return [NSString stringWithFormat:@"%@+%@",button.titleLabel.text,title];
    }];


- (void)button3Action:(UIButton *)button {
    if (self.doubleBlock) {
        [button setTitle:self.doubleBlock(button, button.titleLabel.text)
                forState:UIControlStateNormal];
    }
}

4 非实例，函数包含block，类似afn，系统的动画等

// 简单计算和 是否为0   (其他传入传出与上面类似)
+ (void)calculateA:(NSInteger)a
                 b:(NSInteger)b
              zero:(void(^)())zero
             other:(void(^)())other;// 仅举例使用

+ (void)calculateA:(NSInteger)a
                 b:(NSInteger)b
              zero:(void(^)())zero
             other:(void(^)())other {
    
    if (a + b == 0) {
        if (zero) {
            zero();
        }
        
    } else {
        if (other) {
            other();
        }
    }
}


    [TestView calculateA:2 b:-2 zero:^{
        NSLog(@"一库");
    } other:^{
        NSLog(@"a sa ki");
    }];

2 循环引用

这玩意，简单理解下，就是你中有我，我中有你；但是真的问我，要我解释一下的时候，还真是讲不清个所以然，所以再次研究！

1 首先，三种类型的block

__NSStackBlock__       堆上的block？
__NSMallocBlock__      分配内存的block？
__NSGlobalBlock__      静态全局的block？
// 不管怎么说，先这么叫吧

2 NSMallocBlock：声明copy属性的block实例

@property (nonatomic, copy) void(^outputBlock)(UIButton *button);
- (void)setOutputBlock:(void (^)(UIButton *button))outputBlock;

3 NSStackBlock：直接函数包含block，并不赋值给全局的block

- (void)doSomethingWith:(NSString *)something
                success:(void(^)())success
                failure:(void(^)())failure;

4 特殊情况！

使用typeedf定义，内部使用全局block链接的
typedef UIColor *(^entiretyBlock)(UIButton *button);
- (void)setEntiretyBlock:(entiretyBlock)block;


static entiretyBlock TEMPBLOCK; 
- (void)button3Action:(UIButton *)button {
    if (TEMPBLOCK) {
        button.backgroundColor =  TEMPBLOCK(button);
    }
}
- (void)setEntiretyBlock:(entiretyBlock)block {
    if (block) {
        TEMPBLOCK = block;
    }
}

分情况：未处理 weakself情况下
1）外部调用，block内部没有使用了成员变量：block 和 TEMPBLOCK 都是：__NSGlobalBlock__
2）外部调用，block内部使用了成员变量：block :__NSStackBlock__, TEMPBLOCK:__NSMallocBlock__，而TEMPBLOCK是真正处理事情的

总得来说：
全局的block（__NSMallocBlock__类型的block）导致循环引用，而其他类型的不会。__NSMallocBlock__类的block，跟obj类似了，会产生引用计数，而导致循环引用；

循环引用 - 实测举例：

注：block的循环引用，使用leak 工具都无法检测，马蛋太吊！

1 copy属性的block实例

@property (nonatomic, copy) void(^testMallocBlock)();
- (void)button1Action:(UIButton *)button {
    if (self.testMallocBlock) {
        self.testMallocBlock(button);
    }
}

    __weak typeof(self) weakself = self;
    // 虽然这里没有显示 waring，但是，self持有testView，testView持有block，block又持有self！
    [testView setTestMallocBlock:^{
        self.view.backgroundColor = [UIColor redColor];
//        weakself.view.backgroundColor = [UIColor redColor];
    }];

1 不使用 weakself

在 A po self，分配内存
(lldb) po self
<AViewController: 0x7fdca04a9d50>

pop 回去，按理应该释放 A，但是输出指针，依旧分配了内存
(lldb) po 0x7fdca04a9d50
<AViewController: 0x7fdca04a9d50>

2 使用weakself

(lldb) po self
<AViewController: 0x7f8c7358e930>

pop 回去，输出指针，已经没有指向AViewController了
(lldb) po 0x7f8c7358e930
140241207355696

2 typedef block

typedef void(^staticBlock)();
- (void)testStaticBlock:(staticBlock)block;
static staticBlock TEMPBLOCK;

- (void)button2Action:(UIButton *)button {
    if (TEMPBLOCK) {
        TEMPBLOCK();
    }
}

- (void)testStaticBlock:(staticBlock)block {
    if (block) {
        TEMPBLOCK = block;
    }
}

    __weak typeof(self) weakself = self;
    // 虽然这里没有显示 waring，但是，self持有testView，testView持有block，block又持有self！
    [testView testStaticBlock:^{
        self.view.backgroundColor = [UIColor redColor];
//        weakself.view.backgroundColor = [UIColor redColor];
        NSString *name = @"村长";
        NSLog(@"%@",name);
    }];

1 block内部使用了成员变量，不使用 weakself

(lldb) po self
<BViewController: 0x7ffd82ddb920>

(lldb) po 0x7ffd82ddb920
<BViewController: 0x7ffd82ddb920>

2 block内部使用了成员变量，使用 weakself

(lldb) po self
<BViewController: 0x7fbe01d14a10>

(lldb) po 0x7fbe01d14a10
140454051006992

3 block内部没有使用成员变量！

(lldb) po self
<BViewController: 0x7feae34407c0>

(lldb) po 0x7feae34407c0
140646811961280

3 直接使用 block

(lldb) po self
<CViewController: 0x7feae3613c30>

(lldb) po 0x7feae3613c30
140646813875248

总结：
block是全局的 -> 可能会导致循环引用（区分block 内部是否包含全局属性等）
block是直接方法 -> 不会导致循环引用
多层嵌套是，注意有全局block，都可能导致循环引用

有什么不对的还请指出，谢谢；