Block

1.block本质是封装了函数调用以及函数调用环境的oc对象。自己要会根据源码分析出这个结论记忆会更深刻。
函数调用：函数地址
函数调用环境：block 访问外部的变量
OC对象：有isa指针

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
};

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;
    int age;
};
        int age = 20;
        void (^block)(int, int) =  ^(int a , int b){
            NSLog(@"this is a block! -- %d", age);
            NSLog(@"this is a block!");
            NSLog(@"this is a block!");
            NSLog(@"this is a block!");
        };
        struct __main_block_impl_0 *blockStruct = (__bridge struct __main_block_impl_0 *)block;
        block(10, 10);

2.请分析为什么打印的值是10？
auto int age = 10; //定义出来的局部变量都是auto，可以省略不写，意思是离开所在的大括号会自动销毁
 block = ^{
        // age的值捕获进来（capture）
        NSLog(@"age is %d", age);
  };
age = 20;
block();

因为block具备捕获的能力，在block内已经把10这个值传递给block内部的成员变量了，所以打印10，而这个时候去修改age的值其实是修改的block外部的age。
捕获：block内部会新增一个成员变量正好是外部的变量

3.为什么自动变量是值传递不是指针传递？
因为自动变量在函数执行完后会销毁，销毁后再去访问就是垃圾数据了.
什么是自动把变量？
局部变量分2种：auto、static
auto int age = 10; //定义出来的局部变量都是auto，auto只能修饰局部变量，可以省略不写，意思是离开所在的大括号会自动销毁

void (^block)(void);
void test()
{
    auto int age = 10;
    static int height = 10;
    block = ^{
        // age的值捕获进来（capture）
        NSLog(@"age is %d, height is %d", age, height);
    };
    age = 20;
    height = 20;
}

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        test();
        block(); //age is 10, height is 20
      }
}

4.全局变量为什么不用捕获可以直接访问？
因为谁都可以随时访问就没有必要访问了。
为什么局部变量需要捕获？test已经结束了，block又去访问，要想访问到需要先把值存在block即捕获，即跨函数访问的原因。

5.block变量捕获的种类？3种
变量类型                                           捕获到block内部        访问方式
局部     auto 基本数据类型                          ✔️                      值传递
            auto 对象类型                                  ✔️                 连同其所有权修饰符的指针传递
变量     static                                                ✔️                     指针传递
全局    变量                                                  ×                        直接访问

究竟block会不会捕获只要搞清楚是局部变量还是全局变量就行了

6.下边例子会不会捕获？
会。只要搞清楚是局部变量还是全局变量就行了，因为OC函数默认为传递2个参数（MJPerson * self, SEL _cmd）函数的调用者和方法名。
Person.m
- (void)test {
          void(^block)(void) = ^ {
                  nslog(@"%@",self);
                   nslog(@"%@",_name);//self->name //直接将self捕获，不是单独不会_name，看_name来源，同理[self name]也一样
          }
}

7.block类型有哪几种？
         block类型                                  环境
__NSGlobalBlock__                  没有访问auto变量
__NSStackBlock__                     访问了auto变量
__NSMallocBlock__          __NSMallocBlock__调用了copy

每种block调用copy后的结果:
               block的类                            副本源的配置存储域                    复制结果
__NSConcreteGlobalBlock__                          栈                                         堆
__NSConcreteStackBlock__                         数据段                             什么也不做
__NSConcreteMallocBlock__                          堆                                  引用计数增加

8.ARC下block自动copy的情况有哪些？
在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况
(1)block作为函数返回值时
typedef void (^MJBlock)(void);
MJBlock myblock()
{
    int age = 10;
    return ^{
        NSLog(@"---------%d",age);
    };
}
main() {
        MJBlock block = myblock();
        block();
        NSLog(@"%@", [block class]); //__NSMallocBlock__
}

(2)将block赋值给__strong指针时
        int age = 10;
        MJBlock block = ^{
            NSLog(@"---------%d", age);
        };
        NSLog(@"%@", [block class]); //__NSMallocBlock__

(3)block作为Cocoa API中方法名含有usingBlock的方法参数时
[arr enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
                    
        }];
(4)block作为GCD API的方法参数时
dispatch_once(&onceToken, ^{
            
        });

9.栈和堆访问对象类型的auto变量时都发生了什么？
栈block不会对auto变量产生强引用；
block被拷贝到堆上，block会调用copy函数

10.打印什么？怎么解释？-什么时候被释放的问题？
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    MJPerson *p = [[MJPerson alloc] init];
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"1-------%@", p);
    });
    NSLog(@"touchesBegan:withEvent:");
}
/*
touchesBegan:withEvent:
1-------<MJPerson: 0x6000008f04b0>
MJPerson - dealloc
*/
block作为GCD的参数会发生copy，将栈上的block复制到堆上;
MJPerson *p是对象类型的强引用，在堆block内部会强引用p，在1s后才会释放block，在释放block前会先释放block强引用的p

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    MJPerson *p = [[MJPerson alloc] init];
__weak MJPerson *weakP = p;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"2-------%@", weakP);
    });
    NSLog(@"touchesBegan:withEvent:");
}
/*
touchesBegan:withEvent:
MJPerson - dealloc
2-------(null)
*/
block作为GCD的参数会发生copy，将栈上的block复制到堆上;
在大括号结束时p 会被释放掉；
MJPerson *p是对象类型的弱引用，在堆block内部会弱引用p，在1s后才会释放block，而此时weakP已被释放所以null。

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    MJPerson *p = [[MJPerson alloc] init];
    __weak MJPerson *weakP = p;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"1-------%@", p);
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"2-------%@", weakP);
        });
    });
    NSLog(@"touchesBegan:withEvent:");
}
2021-04-11 11:36:34.831422+0800 Interview03-测试[17362:9913914] touchesBegan:withEvent:
2021-04-11 11:36:34.831549+0800 Interview03-测试[17362:9913914] MJPerson - dealloc
2021-04-11 11:36:35.929587+0800 Interview03-测试[17362:9913914] 2-------(null)
2个block整体看待即可，2s后被释放。

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    MJPerson *p = [[MJPerson alloc] init];
    __weak MJPerson *weakP = p;
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"1-------%@", weakP);
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"2-------%@", p);
        });
    });
    NSLog(@"touchesBegan:withEvent:");
}
2021-04-11 13:41:36.149167+0800 Interview03-测试[17689:9981812] touchesBegan:withEvent:
2021-04-11 13:41:37.149242+0800 Interview03-测试[17689:9981812] 1-------<MJPerson: 0x6000028b4230>
2021-04-11 13:41:39.342495+0800 Interview03-测试[17689:9981812] 2-------<MJPerson: 0x6000028b4230>
2021-04-11 13:41:39.342795+0800 Interview03-测试[17689:9981812] MJPerson - dealloc
2个block整体看待即可,第2个block强引用p，3s后被释放。

总结：看强引用什么时候被释放。就是几秒后被销毁。

11.MRC和ARC下block写法是怎么样的？
MRC下block属性的建议写法
@property (copy, nonatomic) void (^block)(void);

ARC下block属性的建议写法：以下2中写法等价
@property (strong, nonatomic) void (^block)(void); ARC下也会拷贝到堆上
@property (copy, nonatomic) void (^block)(void);

12.有哪些方式可以解决在block内部修改外部变量的值？改为__block,static修饰，全局变量
为什么不用static修饰，全局变量呢？因为static、全局变量会一直在内存中，只是希望在内存中暂时存一下。

13.理解__block变量
__block可以用于解决block内部无法修改auto变量值的问题
__block不能修饰全局变量、静态变量（static）
编译器会将__block变量包装成一个对象

__block int age = 10;
^{
        nslog(@"%d",age);
}();
struct __Block_byref_age_0 {
  void *__isa;
__Block_byref_age_0 *__forwarding;
 int __flags;
 int __size;
 int age;
};
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_age_0 *age; // by ref
}

14.block访问__block基本数据类型、对象类型变量、__block对象类型的区别？
强引用；
由其修饰符决定；
block对__block变量结构体强引用，结构体对对象类型变量由其修饰符决定。

        __block int age = 10;
        NSObject *object = [[NSObject alloc] init]; //这种修饰符默认strong  
        __weak NSObject *weakObject = object;  //这种修饰符默认weak
        MJBlock block = ^{
            NSLog(@"%d", age);  //block强引用object
            NSLog(@"%p", weakObject); //block弱引用weakObject
        };
       block();

block对__block变量结构体强引用，ARC下结构体对对象类型变量由其修饰符决定，
                                                         MRC下结构体对对象类型变量不会强引用。
ARC:
(1)strong情况：
MJBlock block;
        {
           __block MJPerson *person = [[MJPerson alloc] init];
            block = ^{
                NSLog(@"%p", person);// block内部person结构体的person指针默认是 strong  
            };
        }
        block();
        //0x1060575b0
(2)weak情况：
        MJBlock block;
        {
            MJPerson *person = [[MJPerson alloc] init];
            __block __weak MJPerson *weakPerson = person;
            block = ^{
                NSLog(@"%p", weakPerson);//block内部person结构体的person指针默认是 weak
            };
        }
        block();
2021-04-11 23:14:48.230528+0800 Interview01-__block[19517:10315770] -[MJPerson dealloc]
2021-04-11 23:14:48.231074+0800 Interview01-__block[19517:10315770] 0x0

MRC:
main(){
        __block MJPerson *person = [[MJPerson alloc] init];
        MJBlock block = [^{
            NSLog(@"%p", person);
        } copy];
        [person release];
        block();
        [block release];
}
2021-04-11 23:29:27.590414+0800 Interview01-__block[19583:10326096] -[MJPerson dealloc]
2021-04-11 23:29:27.591165+0800 Interview01-__block[19583:10326096] 0x10051bae0
MRC下person被释放了block内部还能访问，说明是弱引用

总结；block对__block变量（基本数据类型、对象类型）结构体一定是强引用。

15、__block变量的内存管理
栈block不会对__block变量(基本数据类型、对象类型)强引用；
当栈block被copy到堆上时，调用block内部copy函数对__block变量(基本数据类型、对象类型)强应用，
当栈block被移除时，调用block内部dispose函数对__block变量(基本数据类型、对象类型)release.

__Block_byref_id_object_copy、__Block_byref_id_object_dispose是对__Block_byref_weakPerson_0内的MJPerson *__weak weakPerson。

(1)对象类型：__main_block_desc_0里copy()、dispose()，对对象类型内存管理
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*); //copy函数在desc结构体里
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc; ///////////////////看这里///////////////////////
  MJPerson *__strong person;
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, MJPerson *__strong _person, int flags=0) : person(_person) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

(2)__block 基本类型：__main_block_desc_0里copy()、dispose()，对__Block_byref_age_0内存管理
struct __Block_byref_age_0 {
  void *__isa;
__Block_byref_age_0 *__forwarding;
 int __flags;
 int __size;
 int age; /////////////////////看这里///////////////////////
};
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  NSObject *p;
  （struct）__Block_byref_age_0 *age; // by ref ///////////////////block对__block 基本类型强引用，C++中可以省略struct///////////////////////
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *_p, __Block_byref_age_0 *_age, int flags=0) : p(_p), age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {////////////////////////////__main_block_copy_0///////////////////////////////
    _Block_object_assign((void*)&dst->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);
    _Block_object_assign((void*)&dst->p, (void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);
    _Block_object_dispose((void*)src->p, 3/*BLOCK_FIELD_IS_OBJECT*/);}

static struct __main_block_desc_0 { //////////////copy、dispose在desc里//////////////
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

(3)__block 对象类型：__main_block_desc_0里copy()、dispose()，对__Block_byref_age_0内存管理，
__Block_byref_weakPerson_0里的__Block_byref_id_object_copy、__Block_byref_id_object_dispose对__Block_byref_weakPerson_0内的MJPerson *__weak weakPerson内存管理;

struct __main_block_desc_0 {//////////////////////////////__main_block_desc_0///////////////////////////////
    size_t reserved;
    size_t Block_size;
    void (*copy)(void);
    void (*dispose)(void);
};

struct __Block_byref_weakPerson_0 {////////__Block_byref_weakPerson_0//////////////////
  void *__isa; // 8
__Block_byref_weakPerson_0 *__forwarding; // 8
 int __flags; // 4
 int __size; // 4
 void (*__Block_byref_id_object_copy)(void*, void*); // 8 ///__Block_byref_id_object_copy//////////
 void (*__Block_byref_id_object_dispose)(void*); // 8 ///__Block_byref_id_object_dispose//////////
 MJPerson *__weak weakPerson;
};

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_weakPerson_0 *weakPerson; // by ref/////////////////////////////////
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_weakPerson_0 *_weakPerson, int flags=0) : weakPerson(_weakPerson->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->weakPerson, (void*)src->weakPerson, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->weakPerson, 8/*BLOCK_FIELD_IS_BYREF*/);}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};

16.理解__forwarding指针：
栈上__block变量结构体的__forwarding 指向自己本身；
发生复制后：此时
栈上__block变量结构体的__forwarding 指向堆上__block变量结构体；
堆上__block变量结构体的__forwarding 指向自己本身；
总结：没发生复制__forwarding指向自己，发生了复制__forwarding指向堆上__block变量的结构。体，即没复制是自己，复制了就是堆区的结构体。

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

18.block循环引用的解决方式有哪些？
ARC:__weak、__block 、__unsafe_unretained（不建议用）。
MRC:__block 、__unsafe_unretained（不建议用）。MRC不支持__weak的

__weak typeof(self) weakSelf = self;
__unsafe_unretained id weakSelf = self; 
self.block = ^{
      printf(@"%p",weakSelf);
}

__block  id weakSelf = self;
self.block = ^{
      printf(@"%p",weakSelf);
      weakSelf = nil;
}
self.block()
缺点：不调用self.block()会产生循环引用，进而造成内存泄漏。

19.block在修改NSMutableArray,需不需要添加__block?不需要。
NSMutableArray *array = [NSMutableArray array];
person.block = ^{
      [arr addObject:@"1"];
} ;

20.__block作用是什么？注意点？
修改局部变量的值，在MRC下block不会对__block变量结构体强引用。

21.block属性修饰词为什么是copy？使用block有哪些注意点？
copy在堆上可以控制block的生命周期，对block进行内存管理。
注意循环引用。