iOS原理篇(四) block原理

Block：能够捕获它所在函数内部的变量的匿名函数

一、block的本质

block本质上也是一个OC对象，它内部也有一个isa指针
将block内部代码会放到_block_func_0函数中，函数地址保存在FuncPtr中
执行block内部代码时是通过FuncPtr找到函数地址进行调用

block的底层结构如下：

int main(int argc, char * argv[]) {
    void (^test)() = ^(){
    };
    test();
}

//__block_imp：  这个是编译器给我们生成的结构体，每一个block都会用到这个结构体
struct __block_impl {
  void *isa;　　　　　　　　　//对于本文可以忽略
  int Flags;　　　　　　　　  //对于本文可以忽略
  int Reserved;　　　　　　　//对于本文可以忽略　　　　　　　
  void *FuncPtr;　　　　　　 //函数指针，这个会指向编译器给我们生成的下面的静态函数__main_block_func_0
};
/*__main_block_impl_0： 
是编译器给我们在main函数中定义的block
void (^test)() = ^(){
};
生成的对应的结构体
*/
struct __main_block_impl_0 {
struct __block_impl impl;  //__block_impl 变量impl
　//__main_block_desc_0 指针，指向编译器给我们生成的结构体变量__main_block_desc_0_DATA 
struct __main_block_desc_0* Desc;　　　
 //结构体的构造函数
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) { 
    impl.isa = &_NSConcreteStackBlock;  //说明block是栈blockimpl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;}
};
//__main_block_func_0： 编译器根据block代码生成的全局态函数，会被赋值给impl.FuncPtr
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    }
//__main_block_desc_0: 编译器根据block代码生成的block描述,
//主要是记录下__main_block_impl_0结构体大小
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} 
 //这里就生成了__main_block_desc_0的变量__main_block_desc_0_DATA
__main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};
//这里就是main函数了
int main(int argc, char * argv[]) {
//__main_block_impl_0()创建了一个__main_block_impl_0结构体的一个实例
//&取地址
//((void (*)())转成函数
//那么这整句就是说定义一个函数指针指向一个新创建的__main_block_impl_0实例的地址。注意创建这个实例时构选函数传的两个参数，
//正是编译器帮我们生成的静态函数__main_block_func_0及__main_block_desc_0的变量__main_block_desc_0_DATA
    void (*test)() = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA)); 
    ((void (*)(__block_impl *))((__block_impl *)test)->FuncPtr)((__block_impl *)test);　                         //下面单独讲
}

当我们声明一个block变量a并为它赋值时，其实就是创建一个函数指针FuncPtr,再根据block a赋值的代码生成一个静态函数，而指针FuncPtr就指向这个静态函数。block a调用时就是使用函数指FuncPtr调用生成的静态函数。

二、block的变量捕获机制

为了保证block内部能够正常访问外部的变量，block有个变量捕获机制

基本变量类型

1、block内部访问auto变量时会将auto变量捕获到block内部，block外部修改auto变量的值并不会影响block内部，所以是值捕获 如下 age变量

2、block访问static变量时会将static变量捕获到block内部，block外部修改static变量的值会影响block内部，所以是指针捕获 如下 height变量

    /*auto：自动变量，离开作用域就会销毁。
    它是默认的关键字，所以通常情况下是省略的。*/
    auto int age = 10;
    static int height = 10;
    void (^block)(void) = ^{
        NSLog(@"age is %d, height is %d", age, height);
    };
    age = 20;
    height = 20;
    block();

 

3、block访问全局变量时不会将全局变量捕获到block内部，而是直接访问。 

总结：局部变量都会被block捕获，自动变量是值捕获，静态变量为地址捕获。全局变量则不会被block捕获

注意：对象的局部auto变量捕获是指针捕获不是值捕获，所以捕获的内容会受外部变量的影响

三、block的类型

Block有三种类型：

• 全局Block：__NSGlobalBlock，
• 堆区Block：__NSMallocBlock，
• 栈区Block：__NSStackBlock

都继承于NSBlock

1、NSGlobalBlock：存放在数据段

没有访问auto类型变量，但是可以访问静态变量或者全局变量。它存储在数据区。
NSGlobalBlock调用copy还是NSGlobalBlock

//MRC下 没有访问auto变量
void (^block)(void) = ^ {
    NSLog(@"Hello world!");
};
NSLog(@"%@", [block class]);  // __NSGlobalBlock__
NSLog(@"%@", [[block class] superclass]);  // NSBlock
NSLog(@"%@", [[[block class] superclass] superclass]);  // NSObject

2、NSStackBlock：存放在栈区

访问auto类型变量的block类型。它存储在栈区。
PS：栈区的数据在调用之后会自动销毁。
NSStackBlock调用copy，会从栈复制到堆。ARC下NSStackBlock当返回值

//MRC下
// 访问了auto变量
int num = 10;
void (^block)(void) = ^ {
    NSLog(@"num = %d", num);
};
NSLog(@"%@", [block class]);  // __NSStackBlock__
//ARC下
- (void)viewDidLoad {
    [super viewDidLoad];
    [self test:^{
       NSLog(@"%@",self.object);
    }];
}
- (void)test:(void(^)(void))block {
    NSLog(@"%@",block); //log: <__NSStackBlock__: 0x7fff5ef49b88>
}

3、NSMallocBlock：存放在堆区
NSMallocBlock调用copy，引用计数增加。对stack类型的block进行copy操作，得出的堆类型的block变量。堆数据需要手动管理内存，需要手动释放。

// NSStackBlock调用了copy
int num = 10;
void (^block)(void) = [^ {
    NSLog(@"num = %d", num);
} copy];
NSLog(@"%@", [block class]);  // __NSMallocBlock__

4、block的自动copy 

在ARC环境下，编译器会根据情况自动将__NSStackBlock转成__NSMallocBlock，比如以下情况：
1、__NSStackBlock作为函数的返回值时

typedef void (^TestBlock)(void);
TestBlock globalBlock(){
    return ^{
        NSLog(@"Hello, globalBlock!");
    };
}
TestBlock mallocBlock(){
    int value = 100;
    return ^{
        NSLog(@"Hello, mallocBlock!%d",value);
    };
}
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        TestBlock block1 =globalBlock();
        TestBlock block2 =mallocBlock();
        NSLog(@"%@",block1);//日志：<__NSGlobalBlock__: 0x100004038>
        NSLog(@"%@",block2);//日志：<__NSMallocBlock__: 0x100650910>
        block1();//日志：Hello, globalBlock!
        block2();//日志：Hello, mallocBlock!100
    }
    return 0;
}

2、将block赋值给__strong指针时

__weak：弱引用变量修饰词，引用计数不会+1，本身可以避免循环引用的问题，但是其会导致外部对象释放了之后，Block内部也访问不到这个对象的问题，我们可以通过在Block内部申明一个__strong的变量来指向weakObj，使外部对象既能在Block内部保持住，又能避免循环引用的问题。

3、block作为Cocoa API中方法名含有usingBlock的方法参数时，例如

NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id  _Nonnull obj, 
NSUInteger idx, BOOL * _Nonnull stop) {     
}];

4、block作为GCD API的方法参数时，例如：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 
(int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{      
});

四、对象类型的auto变量

ARC环境下：person为aotu变量，传入的block的变量同样为person，即block有一个强引用引用person，所以block销毁后，peroson才会销毁。

//ARC环境
typedef void (^Block)(void);
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Block block;
        {
            Person *person = [[Person alloc] init];
            person.age = 10;
            block = ^{
                NSLog(@"------block内部%d",person.age);//对象变量捕获是指针捕获
            };//栈区自动copy到堆区，强引用
        } // 执行完毕，person没有被释放
        NSLog(@"--------");
    } // person 释放
    return 0; 
}

//MRC环境下代码
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        Block block;
        {
            Person *person = [[Person alloc] init];
            person.age = 10;
            block = ^{
                NSLog(@"------block内部%d",person.age);
            };//栈区
            [person release];
        } // person被释放
        NSLog(@"--------");
    }
    return 0;
}

五、__weak,__strong,__block和循环引用

1、__block可以用于解决block内部无法修改auto变量值的问题

编译器会将__block修饰的基本变量类型，包装成一个对象。

block对基本变量类型 捕获就变成了对象变量的捕获，就是指针捕获。之后block内就能修改auto变量值了。

2、block中的循环引用

//self强引用block
self.block = ^{
        NSLog(@"%ld",self.age);
};//栈区自动copy堆区，blcok强引用self对象。

打破任何一方的强引用，就能解决循环引用

 __weak typeof(self) weakSelf = self;
    self.quoteBlock = ^{
        NSLog(@"%ld",weakSelf.age);
    };

在self对象前加了个__weak修饰，block内部就不会对self产生强引用，当block被释放时__weak会自动为nil，不需要block再去释放self了。

1、self释放时通知quoteBlock释放
2、quoteBlock因为没有强引用self，所以无需通知self并等待self先释放，quoteBlock接收到释放通知后就立马释放
3、quoteBlock释放后，self也跟着释放，所以就解决了循环引用的问题