iOS Block

http://events.jianshu.io/p/94db362acb97

 

 

Block的分类

Block有三种类型：全局Block，堆区Block，栈区Block

全局Block

当Block没有引用到局部变量时或者Block里面使用的是全局变量，静态变量时为全局Block

    int a = 10;
    void (^block)(void) = ^{
         NSLog(@"hello world");
    };

    NSLog(@"block:%@", block);

输出结果：block:<__NSGlobalBlock__: 0x104e580f8>
    static int a1 = 20;
    void (^block)(void) = ^{
        NSLog(@"hello - %d",a1);
    };

    NSLog(@"block:%@", block);
输出结果：block:<__NSGlobalBlock__: 0x100cec0f8>

堆区Block

当Block里有引用到局部变量时为堆区block

    int a = 10;
    void (^block)(void) = ^{
        NSLog(@"hello - %d",a);
    };

    NSLog(@"block:%@", block);
输出结果：block:<__NSMallocBlock__: 0x281065950>
    __block int a = 10;
    void (^block)(void) = ^{
        NSLog(@"hello - %d",a);
    };

    NSLog(@"block:%@", block);
输出结果：block:<__NSMallocBlock__: 0x281aad5c0>

栈区Block

在Block名前面加个__weak就是栈区block

    __block int a = 10;
    static int a1 = 20;
    void (^__weak block)(void) = ^{
        NSLog(@"hello - %d",a);
        NSLog(@"hello - %d",a1);
    };

    NSLog(@"block:%@", block);
输出结果：block:<__NSStackBlock__: 0x16f7ccfb0>

堆Block和栈Block的区别

接下来看看这两种block有什么区别呢？
先看个示例：

    __block int a = 10;
    __block int b = 20;
    NSLog(@"a:%p---b:%p", &a, &b);
    void (^__weak block)(void) = ^{
        NSLog(@"hello - %d---%p",a, &a);
        a++;
    };
    void (^block1)(void) = ^{
        NSLog(@"hello - %d---%p",b, &b);
        b++;
    };
    block();
    block1();
    NSLog(@"block:%@---block1:%@", block, block1);
    NSLog(@"a:%d---b:%d", a, b);
    NSLog(@"a:%p---b:%p", &a, &b);
输出结果：
a:0x16bb7cfe8---b:0x16bb7cfc8
hello - 10---0x16bb7cfe8
hello - 20---0x283e0b1b8
block:<__NSStackBlock__: 0x16bb7cf70>---block1:<__NSMallocBlock__: 0x28307d9b0>
a:11---b:21
a:0x16bb7cfe8---b:0x283e0b1b8

通过结果我们看到，首先block的地址是在栈区，而block1的地址是在堆区，而栈block引用的变量a的地址并没有变化，而堆block1引用的变量b的地址也相应变成了堆区0x283e0b1b8，并且后面使用的b的地址都是堆区上的。
总结：栈block存放在栈区，对局部变量引用只拷贝局部变量的地址，而堆block存放在堆区，并且直接将局部变量拷贝了一份到堆空间。
接下来我们再来看个示例：

NSObject *objc = [NSObject new];
    NSLog(@"%@---%ld",objc, CFGetRetainCount((__bridge CFTypeRef)(objc)));// 1
    // block 底层源码
    // 捕获 + 1
    // 堆区block
    // 栈 - 内存 -> 堆  + 1
    void(^strongBlock)(void) = ^{ // 1 - block -> objc 捕获 + 1 = 2
        NSLog(@"%@---%ld",objc, CFGetRetainCount((__bridge CFTypeRef)(objc)));
    };
    strongBlock();

    void(^__weak weakBlock)(void) = ^{ // + 1
        NSLog(@"%@---%ld",objc, CFGetRetainCount((__bridge CFTypeRef)(objc)));
    };
    weakBlock();
    
    void(^mallocBlock)(void) = [weakBlock copy];
    mallocBlock();
输出结果：
<NSObject: 0x28292ff20>---1
<NSObject: 0x28292ff20>---3
<NSObject: 0x28292ff20>---4
<NSObject: 0x28292ff20>---5

奇怪为什么堆区block里面的对象引用计数加2呢？而后面的mallocBlock只加1呢？
首先objc在strongBlock里面必然会拷贝一份到堆区，所以会加1，但是他是从当前函数的栈区拷贝吗？并不是，对于堆区Block一开始编译时是栈block这时候objc对象地址拷贝了一份引用计数加1，后面从栈block变成堆block，又拷贝了一份引用计数又加1，所以这时候是3
weakBlock是栈block仅拷贝了一份，所以引用计数加1，这时候是4
mallocBlock从weakblock拷贝了一份，所以引用计数再加1，这时候是5
相当于strongBlock = weakblock + void(^mallocBlock)(void) = [weakBlock copy];

再来看个示例：

    NSObject *a = [NSObject alloc];
    NSLog(@"1---%@--%p", a, &a);
    void(^__weak weakBlock)(void) = nil;
    {
        // 栈区
        void(^__weak strongBlock)(void) = ^{
            NSLog(@"2---%@--%p", a, &a);
        };
        weakBlock = strongBlock;
        strongBlock();
        NSLog(@"3 - %@ - %@",weakBlock,strongBlock);
    }
    weakBlock();
    NSLog(@"4---%@--%p", a, &a);
输出结果：
1---<NSObject: 0x2820337a0>--0x16bcf4fd8
2---<NSObject: 0x2820337a0>--0x16bcf4fc0
3 - <__NSStackBlock__: 0x16bcf4fa0> - <__NSStackBlock__: 0x16bcf4fa0>
2---(null)--0x16bcf4fc0
4---<NSObject: 0x2820337a0>--0x16bcf4fd8

当前是栈区strongBlock的赋值给外面的栈区weakBlock，因为都是存放在栈空间的，只有当前函数结束才会被销毁，随意这边weakBlock调用并不会有什么问题。如果换成堆区block就不一样了
注意：这边的a对象在weakBlock()调用时是nil，通过上面打印可以看出a对象在进入到strongblock里，&a拷贝了一份，拷贝的这一份地址指向的跟外面一样，但是当strongblock出了{},尽管strongblock对象不再了，但是其指向的内存空间还在，销毁之前给了外面的weakBlock，同理a也一样，对象(此时a指向的内容)不在了，但是内存空间却还在。

NSObject *a = [NSObject alloc];
//    NSLog(@"1---%@--%p", a, &a);
    void(^__weak weakBlock)(void) = nil;
    {
        // 堆区
        void(^strongBlock)(void) = ^{
            NSLog(@"2---%@--%p", a, &a);
        };
        weakBlock = strongBlock;
        strongBlock();
        NSLog(@"3 - %@ - %@",weakBlock,strongBlock);
    }
    weakBlock();
//    NSLog(@"4---%@--%p", a, &a);
输出结果：
2---<NSObject: 0x281218810>--0x281e7f6e0
3 - <__NSMallocBlock__: 0x281e7f6c0> - <__NSMallocBlock__: 0x281e7f6c0>
调用weakBlock时崩溃

为什么呢？因为在{}里面的堆区strongBlock出了大括号就会被销毁，此时你去调用这个block就会崩溃
注意：这边weakBlock为什么也是__NSMallocBlock__，其实weakBlock相当于是指针，此时指向的是一个堆上的内存所以是__NSMallocBlock__

Block的循环引用

内存泄漏一个主要原因就是block的循环引用。那么如何解决循环引用呢？

- (void)viewDidLoad {
    [super viewDidLoad];
    // 循环引用
    self.name = @"hongfa";
    self.block = ^{
        NSLog(@"%@", self.name);
    }
    
    self.block();
}

这边vc 引用了block ，block引用了vc，最后面造成了循环引用，那么如何解决呢？
方案一：通过weak来解决

- (void)viewDidLoad {
    [super viewDidLoad];
    // 循环引用
    self.name = @"hongfa";
    __weak typeof(self) weakself = self;
    self.block = ^{
        NSLog(@"%@", weakself.name);
    };
    
    self.block();
}
直接使用weakself来代替self，weakself是弱引用，这样不会导致引用计数+1。
这边也有一个问题如下：
    self.name = @"hongfa";
    __weak typeof(self) weakself = self;
    self.block = ^{
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", weakself.name);
        });
    };
    
    self.block();

如果当我们延迟使用weakself的话，这时候的weakself可能已经被销毁了，这时候就需要用到__strong typeof(weakself) strongself = weakself;

    self.name = @"hongfa";
    __weak typeof(self) weakself = self;
    self.block = ^{
        __strong typeof(weakself) strongself = weakself;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", strongself.name);
        });
    };
    
    self.block();

__strong可以让对象暂时在存活一段时间，用完就会销毁，这样也不会带来内存泄漏。
以上就是通过__weak和__strong来解决block的循环引用。
方案二：通过临时变量来解决

    __block ViewController *vc = self;
    self.block = ^(void){
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",vc.name);
            vc = nil;
        });
    };
    self.block();

定义一个跟self一样类型的vc = self，然后block引用vc，用完之后再把vc=nil，这样引用链：self -> block -> vc -> self这样也可以解决循环引用问题

方案三：通过参数将self传进去，传参的话，参数是在栈区，函数运行好栈区销毁参数也就跟着销毁，所以也可以解决循环引用问题

   // 通讯 参数 block 通知
    self.hfblock = ^(ViewController *vc){
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@",vc.name);
        });
    };
    self.hfblock(self);

以上就是目前掌握的三种解决循环引用的方案。

block的本质

接下来看看block通过xcrun后究竟是什么？

int main(int argc, char * argv[]) {
    int a = 9;
    __block int b = 10;
    NSObject *objc = [NSObject alloc];
    void(^Block)(void) = ^{
        NSLog(@"a:%d", a);
        NSLog(@"b:%d", b);
        NSLog(@"objc:%@", objc);
    };
    return 0;
}

xcrun -sdk iphonesimulator clang -rewrite-objc main.m
int main(int argc, char * argv[]) {
    int a = 9;
    __attribute__((__blocks__(byref))) __Block_byref_b_0 b = {(void*)0,(__Block_byref_b_0 *)&b, 0, sizeof(__Block_byref_b_0), 10};

    NSObject *objc = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc"));

    void(*Block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, a, objc, (__Block_byref_b_0 *)&b, 570425344));
    return 0;
}

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int a;
  NSObject *objc;
  __Block_byref_b_0 *b; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _a, NSObject *_objc, __Block_byref_b_0 *_b, int flags=0) : a(_a), objc(_objc), b(_b->__forwarding) { // 构造函数
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

struct __Block_byref_b_0 {
  void *__isa;
__Block_byref_b_0 *__forwarding;
 int __flags;
 int __size;
 int b;
};

xcrun后看到的__block b，底层是变成了结构体b，里面保存了b的值10，整个block也变成了__main_block_impl_0结构体对象，把a, b, objc作为参数传进去。而在block结构体里定义了三个成员变量来保存a,b,objc
通过上面的例子我们就很清楚block的底层结构以及他是如何对引用局部变量

作者：Kates
链接：http://events.jianshu.io/p/94db362acb97
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。