前言

我承认我被网上很多的讲解误导了，导致我在做一些连贯性的思考时，思维走不通了。 不服气的我进行了一些深挖，因为我要让自己理解这些知识点的时候更顺畅一些。

所谓Block就是Objective-C对象,对象就是结构体。

Block简单介绍

虽然我没有经历过MRC，但是我还是要说现在已经是ARC时代了，当Block作为属性的时候用strong修饰就好了，Block在栈上创建，如果你想持有Block则必须将其拷贝到堆上，在MRC环境下需要我们使用copy进行修饰它才会被拷贝到堆上，而ARC环境下它会被自动拷贝到堆上面,因为ARC会自动区分某些情况而决定是否将Block拷贝到堆上。

既然Block在堆上面，那就请让我把它当做对象看待吧。

疑问

首先抛出一个疑问， 大家在哪里用到下面的代码？为什么要用呢？原理是什么呢？

__weak typeof(self) weakSelf = self;
__strong typeof(self) strongSelf = weakSelf；/// 与另外一种strongSelf的实现方式strongify效果一样

循环引用

这是Block被说烂了的一个话题，而被说烂了的解决方法是使用__weak、__strong进行weakSelf、strongSelf操作，以下的self均是指ViewController1控制器的对象：

__weak typeof(self) weakSelf = self;
__strong typeof(self) strongSelf = weakSelf;

Demo场景

Snip20170902_9.png

延迟加载的目的是为了让界面先退出，再执行Block。这里也是为了模拟异步的请求操作，有些请求可能会在我们页面销毁后依旧在执行。我们知道界面退出时是要进行一些内存的操作的，如果内存没有泄露则会释放掉控制器的内存，执行dealloc方法。ViewController1代码如下：

@interface ViewController1 (){
    BOOL _test;
}
@property (nonatomic, strong) void (^study)(void);
@end


///.m文件
@implementation ViewController1
- (void)dealloc {
    NSLog(@"%s", __func__);
}

- (void)viewDidLoad {
    [super viewDidLoad];
  
   __weak typeof(self) weakSelf = self;
    self.study = ^{
       /// 示例代码
    };
    self.study();
}
@end

weakSelf可能引发的Crash

将上述代码改为：

 __weak typeof(self) weakSelf = self;
    self.study = ^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"weakSelf:%@", weakSelf);
            
            weakSelf->_test = YES;
        });
    };
    self.study();

其中_test为实例变量，因为直接使用_test会造成循环引用，那么为什么呢？

猜想

_test作为当前对象self指向内存的一个实例变量，要想访问_test那么你只能通过self，所以Blcok需要持有self。

验证

示例代码：

- (void)test {
    self.study = ^{
        _test = YES;
    };
    self.study();
}

编译后的Block代码

• Block对象本身

/// 创建的Block结构体，所以说Block就是对象。 命名规则：根据Block所属的函数名(此处为test)和该Blcok语法在函数出现的顺序值（此处为0）来命名。
struct __ViewController1__test_block_impl_0 {
  struct __block_impl impl; /// 记录Block的isa类指针以及实现代码的函数指针，每一个Block对象都会有这样一个结构体成员变量(下面有定义)
  struct __ViewController1__test_block_desc_0* Desc; /// 记录版本升级所需的区域和Block的大小，以及某些进行拷贝、释放成员变量的函数指针，每一个Block对象的Desc会不一样，因为成员变量的个数就不一样(下面有定义)
  ViewController1 *const __strong self; /// 成员变量，用于记录捕获的变量

/// 初始化Block的构造函数，用于初始化
  __ViewController1__test_block_impl_0(void *fp, struct __ViewController1__test_block_desc_0 *desc, ViewController1 *const __strong _self, int flags=0) : self(_self) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc; /// 指向默认初始化的__ViewController1__test_block_desc_0_DATA
  }
};

• __block_impl结构体

/// 所有的BLock都会有这样的一个结构体变量
struct __block_impl {
  void *isa; /// _NSConcreteStackBlock指向NSConcreteStackBlock类，表明该Block对象目前在栈上面，当Block被拷贝到堆上时，这个值变为_NSConcreteMallocBlock。与OC对象的isa指针是一样的。
  int Flags;
  int Reserved;
  void *FuncPtr; /// 指向具体的实现代码的函数指针
};  

• __ViewController1__test_block_desc_0结构体（切记copy方法在Block拷贝到堆上面才会调用）

/// Desc成员变量的结构体定义，前两个成员变量每一个这样的结构体都会有,后面的两个方法将会与成员变量，（OC 对象）相对应，比如这里这有一套对应这里的成员变量self，后面均有0这个flag。同时也默认初始化了该类型的__ViewController1__test_block_desc_0_DATA结构体变量。
static struct __ViewController1__test_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __ViewController1__test_block_impl_0*, struct __ViewController1__test_block_impl_0*); /// 相当于对应成员变量的retain操作，该方法会在Block拷贝到堆上时调用。
  void (*dispose)(struct __ViewController1__test_block_impl_0*); /// 相当于Release操作，Block被释放时调用，也相当于Dealloc方法。
} __ViewController1__test_block_desc_0_DATA = { 0, sizeof(struct __ViewController1__test_block_impl_0), __ViewController1__test_block_copy_0, __ViewController1__test_block_dispose_0};

• Block的初始化

/// 在Test方法调用Block的构造函数初始化Block
static void _I_ViewController1_test(ViewController1 * self, SEL _cmd) {
    ((void (*)(id, SEL, void (*)()))(void *)objc_msgSend)((id)self, sel_registerName("setStudy:"), ((void (*)())&__ViewController1__test_block_impl_0((void *)__ViewController1__test_block_func_0, &__ViewController1__test_block_desc_0_DATA, self, 570425344)));
    ((void (*(*)(id, SEL))())(void *)objc_msgSend)((id)self, sel_registerName("study"))();
}

简化初始化Block的代码就是：
__ViewController1__test_block_impl_0((void *)__ViewController1__test_block_func_0, &__ViewController1__test_block_desc_0_DATA, self, 570425344)
/// 可以看到Blcok初始化时传递的参数为self

• Block的具体实现代码

/// Block的具体实现代码
static void __ViewController1__test_block_func_0(struct __ViewController1__test_block_impl_0 *__cself) {
  ViewController1 *const __strong self = __cself->self; /// __cself代表当前的Block对象

        (*(BOOL *)((char *)self + OBJC_IVAR_$_ViewController1$_test)) = ((bool)1);
    }

我们可以看到Block在通过构造函数初始化的时候传递的参数为self，而内部的成员变量self通过__strong修饰符引用了self。 所以就有了上面的 weakSelf->_test = YES，使用weakSelf创建的成员变量为：

ViewController1 *const __weak weakSelf;

退出界面然后程序崩溃了

控制台的输出如下：

2017-09-02 19:21:27.934 CommonTest[12765:1788625] -[ViewController1 dealloc]
2017-09-02 19:21:29.916 CommonTest[12765:1788625] weakSelf:(null)

这个很好理解，因为控制器退出时并不存在循环引用内存泄漏，所以控制器被释放，__weak修饰的指针weakSelf被自动置为nil，而weakSelf->_test是结构体的操作相当于直接去访问_test的内存块，而weakSelf已经为nil相当于野指针，在c语言中访问野指针是不被允许的。

这只是一般情况，平时我们通过点语法访问属性或者调用方法，实际上是在向某个对象发送消息，而OC中向nil发送消息是不会崩溃的。 所以有许多异步的操作在界面销毁后依然不会产生崩溃。

于是这就需要用到strongSelf了。

strongSelf

将代码修改为：

 __weak typeof(self) weakSelf = self;
    self.study = ^{
        __strong typeof(self) strongSelf = weakSelf;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"strongSelf:%@", strongSelf);
            
            strongSelf->_test = YES;
        });
    };
    self.study();

打印结果为：

2017-09-02 19:43:46.140 CommonTest[13209:1897215] strongSelf:<ViewController1: 0x7fe55d01afa0>
2017-09-02 19:43:46.141 CommonTest[13209:1897215] -[ViewController1 dealloc]

是的，控制器在Block代码执行之后释放的。

编译后的Block实现代码：

 Student *const __weak weakSelf = __cself->weakSelf; 

        __attribute__((objc_ownership(strong))) typeof(self) strongSelf = weakSelf;
        dispatch_after(dispatch_time((0ull), (int64_t)(3.0 * 1000000000ull)), dispatch_get_main_queue(), ((void (*)())&__Student__test_block_impl_0((void *)__Student__test_block_func_0, &__Student__test_block_desc_0_DATA, strongSelf, 570425344)));

可以看到生成了两个局部变量__weak weakSelf、strongSelf，首先生成了一个弱引用的指针常量指向实例变量weakSelf，然后由strongSelf强引用它，最终强引用的是当前的控制器，在某种程度上这里形成了循环引用。
因为界面退出后，strongSelf没有被释放，所以控制器的内存是无法被释放的。

只是当Block实现代码执行完毕后strongSelf会被释放，这里对于控制器的强引用会被断开，控制器也会被释放。

于是你即便将代码改成这样也是等效的：

 __weak typeof(self) weakSelf = self;
    self.study = ^{
       __strong NSObject *strongSelf = weakSelf;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"strongSelf:%@", strongSelf);
            
            ((ViewController1 *)strongSelf)->_test = YES;
        });
    };
    self.study();

strongSelf可能引发的Crash

我想大多数时候我们都没有考虑到这一点，将上述strongSelf的例子代码改一下，只是将strongSelf定义的位置改变一下，将他放到dispatch的block中,你们觉得有问题吗？

 __weak typeof(self) weakSelf = self;
    self.study = ^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            __strong typeof(self) strongSelf = weakSelf;
            NSLog(@"strongSelf:%@", strongSelf);
            
            strongSelf->_test = YES;
        });
    };
    self.study();

是的，程序崩掉了，因为控制器已经被释放了。

解析

当我们调用Block的时候，过了3秒才去创建strongSelf局部变量，而此时控制器已经被释放了。 许多异步加载的代码和这个类似， 所以最好加上strongSelf是否为nil，避免误操作。

简单的例子

首先创建一个Student类,设置Student的单例对象的block属性study,同时调用test方法延迟执行执行Block。

创建单例对象的目的是为了Student对象的Block不被释放。

@interface Student : NSObject

@property (nonatomic, strong) void (^study)(void);
+ (instancetype)sharedInstance;
- (void)test;
@end


@implementation Student

- (void)dealloc {
    NSLog(@"%s", __func__);
}

+ (instancetype)sharedInstance {
    static Student *stu = nil;
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        stu = [[self alloc] init];
    });
    
    return stu;
}

/// study的setter方法 暂且先注释掉， 这样写会导致崩溃
//- (void)setStudy:(void (^)(void))study {
//    _study = study;
//}

- (void)test {
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        self.study();
    });
}

@end

将ViewController1中的代码改为如下：

 [Student sharedInstance].study = ^{
        NSLog(@"%@", self);
    };
    
  [[Student sharedInstance] test];

首先想想上述的代码是否会造成内存泄漏？

答案是肯定的。按照我们上面的理解，这里是不存在循环引用的。但是单例的Block没有被释放，因此初始化这个Block时创建的成员变量ViewController1 *const __strong self;对控制器的强引用也不会被释放。 所以这里是存在内存泄漏的。

Block的setter

对于上述block的setter方法，会导致test处的EXE_BAD_ACCESS错误，也就是说Block并没有被拷贝到堆上，因为我重写了系统的setter方法，系统的setter会进行copy操作。改为下面的方式即可。

/// study的setter方法
- (void)setStudy:(void (^)(void))study {
    _study = [study copy]; // 对于Block的setter重写，需要手动调用copy。
}

系统的Block的setter方法（编译后的可执行文件代码）：

void -[ViewController1 setStudy:](int arg0, int arg1, int arg2) {
    objc_setProperty_nonatomic_copy(arg0, arg1, arg2, *_OBJC_IVAR_$_ViewController1._study);
/// objc_setProperty_nonatomic_copy就是进行属性的copy操作
    return;
}

我只想说，这么一个小小的失误折磨了我好久好久！--

总结

上面的例子和我们异步加载的操作类似，因此只要Block不被持有，那么直接用self也不会存在内存泄漏的问题。

Stay hungry，Stay foolish！