__block和__weak的区别

一、__block

优点：

• 扩大变量的作用域。</br>
• 控制对象的生命周期，防止循环引用。
• 是强引用，在非ARC环境下可以使用 __block替代__weak</br>

<pre>
int a = 0;
self.theBlock = ^(){
a = 2;
};
报错，a的值不能被修改，因为这里只是简单的值传递。
__block int a = 0;
self.theBlock = ^(){
a = 2;
};
编译通过，指针传递。

下面来看看block的作用域，block有以下三种：
1._NSConcreteStackBlock 保存在栈中的block，出栈时会被销毁
2._NSConcreteGlobalBlock 全局的静态block，不会访问任何外部变量
3._NSConcreteMallocBlock 保存在堆中的block，当引用计数为0时会被销毁
一般我们接触到得是在栈上生成的block。当我们把Block作为全局变量使用时：
void (^block)(void) = ^{NSLog(@"This is a Global Block");};

int main(int argc, const char * argv[]) {
@autoreleasepool {
block();
}
return 0;
}
分配在全局变量上的Block,在变量作用域外也可以通过指针安全的访问。</br>但分配在栈上的Block，如果它所属的变量作用域结束，该Block就被废弃。
同样地, __block变量也分配在栈上，当超过该变量的作用域时，该__block变量也会被废弃。

循环引用:我们可以使用下述代码解除Block循环引用的问题
__block id tmp = self;
void(^block)(void) = ^{
tmp = nil;
};
block();
通过执行block方法，nil被赋值到__block变量tmp中。这个时候__block变量对 self
的强引用失效，从而避免循环引用的问题。缺点是执行block才能解除循环引用。
</pre>

我们一般可以使用copy方法手动将 Block 或者 block变量从栈复制到堆上。
比如我们把Block做为类的属性访问时，我们一般把该属性设为copy。

在MRC环境下，__block是弱引用，在ARC环境下是强引用，亲测，很奇怪

二、__weak

优点：

• 弱引用，防止循环引用

.h
@property (nonatomic, strong) People \*myPeople;
@property (nonatomic, strong) void(^theBlock)();
.m
    self.theBlock = ^(){
        self.myPeople.name = @"ddd";
    };

当出栈，之后controller的dealloc（）方法未被调用
作如下修改

self.theBlock = ^(){
        weakSelf.myPeople.name = @"ddd";
    };

dealloc()被调用，在MRC环境下用retainCount方法也能看到引用计数的变化
总结：
__weak本身可以防止循环引用，但是当block外部的变量释放之后，里面也会出现访问不到对象的问题，这时候，在block里面用__strong来修饰weakObj，就可以使外部对象既能保持住，又能防止循环引用。
参考文档
__weak与__block区别
黑幕背后的__block修饰符
Objective-C中的Block

@3楼
在start()方法结束后2秒，打印shop的string属性，如下
**
2017-03-25 18:11:01.749 TestWeak[57495:1819695] shop --0x7fff507bbb58
2017-03-25 18:11:01.750 TestWeak[57495:1819695] weakShop --0x7fff507bbb50
2017-03-25 18:11:03.750 TestWeak[57495:1819695] (null)
**
shop已经被释放，string属性没能成功打印

- (void)viewDidLoad {
    [super viewDidLoad];
    [self start];
}

-(void)start{
    RBShop *shop = [[RBShop alloc] init];
    shop.string = @"welcome";
    __weak typeof(shop) weakShop = shop;
    shop.myBlock = ^(){
        
//        RBShop *strongshop = weakShop;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",weakShop.string);
//            NSLog(@"strongshop -- %p",&strongshop);
        });
        
    };
    shop.myBlock();
    NSLog(@"shop --%p",&shop);
    NSLog(@"weakShop --%p",&weakShop);

}```
将注释打开

-(void)start{
RBShop *shop = [[RBShop alloc] init];
shop.string = @"welcome";
__weak typeof(shop) weakShop = shop;
shop.myBlock = ^(){

    RBShop *strongshop = weakShop;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",strongshop.string);
        NSLog(@"strongshop -- %p",&strongshop);
    });
    
};
shop.myBlock();
NSLog(@"shop --%p",&shop);
NSLog(@"weakShop --%p",&weakShop);

}

打印如下
**
2017-03-25 18:12:26.753 TestWeak[57516:1821278] shop --0x7fff5d856b58
2017-03-25 18:12:26.754 TestWeak[57516:1821278] weakShop --0x7fff5d856b50
2017-03-25 18:12:28.946 TestWeak[57516:1821278] welcome
2017-03-25 18:12:28.947 TestWeak[57516:1821278] strongshop -- 0x608000248f60
**
最后数据打印了出来，shop也释放了

针对**在block里面用__strong来修饰weakObj，就可以使外部对象既能保持住，又能防止循环引用**这句话：
>在block里面再对weakshop进行一次强引用，这里的生成的strongshop，不会干扰外部的对象，当cgd内部的block执行结束就会释放掉shop