iOS开发-7.Block

• 1.block的本质

a) block本质上也是一个OC对象，它内部也有个isa指针

b) block是封装了函数调用以及函数调用环境的OC对象

c) block的底层结构如图

d) block底层代码实现

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  // 构造函数（类似于OC的init方法），返回结构体对象
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

// 封装了block执行逻辑的函数
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_2r__m13fp2x2n9dvlr8d68yry500000gn_T_main_c60393_mi_0);
        }
        
// desc描述函数
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};

// main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
        // 定义block变量
        void (*block)(void) = &__main_block_impl_0(
                                                   __main_block_func_0,
                                                   &__main_block_desc_0_DATA
                                                   );

        // 执行block内部的代码
        block->FuncPtr(block);
    }
    return 0;
}

• 2.block的变量捕获（capture）

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

b) 局部变量需要捕获的原因，是因为你在跨函数访问

c) 全局变量你在那里都可以访问，所以不会捕获

• 3.auto变量的捕获
  

• 4.block的类型

a) block有3种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型
    1) __NSGlobalBlock__ （ _NSConcreteGlobalBlock ）
    2) __NSStackBlock__ （ _NSConcreteStackBlock ）
    3) __NSMallocBlock__ （ _NSConcreteMallocBlock ）
    
b) 访问了局部变量的block是放到栈段，打印出来是malloc类型是ARC处理了,关闭了ARC即能够拿到真实类型,既然是放到栈上面，离开了作用域，内存就会释放，所以以后在访问block就可能出现垃圾数据

c) 应用程序的内存分配&block存储的区域
    1) 程序区域(代码段) 地址值比较小
    2) 数据区域(放全局变量:在函数外面定义的变量) 
    3) 堆:动态分配内存,需要程序员申请内存,也需要程序员管理内存(alloc出来的对象)
    4) 栈:(放局部变量:在函数里面定义的变量,系统自动分配和销毁内存)

d) block类型环境

e) 每一种类型的block调用copy后的结果

• 5.block的copy

a) 在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况
    1) block作为函数返回值时
    2) 将block赋值给__strong指针时
    3) block作为Cocoa API中方法名含有usingBlock的方法参数时
    4) block作为GCD API的方法参数时
    
b) MRC下block属性的建议写法
    1) @property (copy, nonatomic) void (^block)(void);
    
c) ARC下block属性的建议写法
    1) @property (strong, nonatomic) void (^block)(void);
    2) @property (copy, nonatomic) void (^block)(void);
    
d) block用copy来修饰，无论mrc还是arc都是一致的，在arc环境下，strong和copy是没区别的

• 6.对象类型的auto变量

a) 当block内部访问了对象类型的auto变量时
    1) 如果block是在栈上，将不会对auto变量产生强引用(mrc环境验证)
    2) 栈空间上的block是不会保住person对象的命的即不会强引用或者弱引用，但是person的释放跟自身的引用计数为不为0挂钩
    3) block访问对象类型就会多出copy和dispose方法,需要对对象retain和release操作,内存管理操作
    4) block引用的对象什么时候释放就看对象本身的强引用什么时候释放
    
b) 如果block被拷贝到堆上
    1) 会调用block内部的copy函数
    2) copy函数内部会调用_Block_object_assign函数
    3) _Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用
    
c) 如果block从堆上移除
    1) 会调用block内部的dispose函数
    2) dispose函数内部会调用_Block_object_dispose函数
    3) _Block_object_dispose函数会自动释放引用的auto变量（release）

• 6.使用clang转换OC为C++代码时，可能会遇到问题解决

a) 在使用clang转换OC为C++代码时，可能会遇到以下问题
    1) cannot create __weak reference in file using manual reference
    
b) 解决方案：支持ARC、指定运行时系统版本，比如
    1) xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m

• 7.__block修饰符

a) __block可以用于解决block内部无法修改auto变量值的问题
    1) block为什么不能直接修改外部的局部变量，可以从底层本质角度去解读，2个不同的函数，肯定不能在另外一个函数去修改另一个函数的局部变量，2个函数的栈空间是不一样的，一个调完了，另外一个可能就不存在了
    2) 此时你又想去改的做法变成static局部变量或者全局变量(那么变量就会一直在内存中)
    3) 可以用__block来解决问题，直接修改指针的时候才需要加，会将数据包装成一个对象
    
b) __block不能修饰全局变量、静态变量（static）

c) 编译器会将__block变量包装成一个对象

• 8.__block的内存管理

a) 当block在栈上时，并不会对__block变量产生强引用

b) 当block被copy到堆时
    1) 会调用block内部的copy函数
    2) copy函数内部会调用_Block_object_assign函数
    3) _Block_object_assign函数会对__block变量形成强引用（retain）

c) 当block从堆中移除时
    1) 会调用block内部的dispose函数
    2) dispose函数内部会调用_Block_object_dispose函数
    3) _Block_object_dispose函数会自动释放引用的__block变量（release）

• 8.__block的__forwarding指针
  

• 9.对象类型的auto变量、__block变量

a) 当block在栈上时，对它们都不会产生强引用

b) 当block拷贝到堆上时，都会通过copy函数来处理它们
    1) __block变量（假设变量名叫做a）
_Block_object_assign((void*)&dst->a, (void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);

    2) 对象类型的auto变量（假设变量名叫做p）
_Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);

c) 当block从堆上移除时，都会通过dispose函数来释放它们
    1) __block变量（假设变量名叫做a）
_Block_object_dispose((void*)src->a, 8/*BLOCK_FIELD_IS_BYREF*/);

    2) 对象类型的auto变量（假设变量名叫做p）
_Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);

• 10.__block修饰的对象类型

a) 当__block变量在栈上时，不会对指向的对象产生强引用

b) 当__block变量被copy到堆时
    1) 会调用__block变量内部的copy函数
    2) copy函数内部会调用_Block_object_assign函数
    3) _Block_object_assign函数会根据所指向对象的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用（注意：这里仅限于ARC时会retain，MRC时不会retain）

c) 如果__block变量从堆上移除
    1) 会调用__block变量内部的dispose函数
    2) dispose函数内部会调用_Block_object_dispose函数
    3) _Block_object_dispose函数会自动释放指向的对象（release）
    
d) 用__block修改基本数据类型/对象类型生成的自身__block结构体多出了copy&dispose的方法

• 11.循环引用问题

a) 什么是循环引用？

b) 解决循环引用问题 - ARC

c) 解决循环引用问题 - MRC

d) __weak 只能用来修饰OC对象

e) __weak和__unsafe_unretained区别
    1) __weak：不会产生强引用，指向的对象销毁时，会自动让指针置为nil
    2) __unsafe_unretained：不会产生强引用，不安全，指向的对象销毁时，指针存储的地址值不变

• 12.block常见面试题快速作答

a) block的原理是怎样的？本质是什么？
    1) 封装了函数调用以及调用环境的OC对象

b) __block的作用是什么？有什么使用注意点？

c) block的属性修饰词为什么是copy？使用block有哪些使用注意？
    1) block一旦没有进行copy操作，就不会在堆上
    2) 使用注意：循环引用问题

d) block在修改NSMutableArray，需不需要添加__block？
    1) 不需要