block概念

block本质上是一个OC对象（结构体），它享有所有OC对象的待遇，只不过普通OC对象用来封装数据，而block用来封装函数以及函数的调用环境。所谓封装函数，是指block内部会把block的参数、返回值、执行体封装成一个函数，并且存储该函数的内存地址；所谓封装函数的调用环境，是指block内部会捕获变量，并且存储这些捕获的变量。

block分类

• NSGlobalBlock 全局block，位于内存全局区，未引用任何局部变量

void (^block)(void) = ^{
        NSLog(@"Cooci");
    };
    NSLog(@"%@",block);

• NSMallocBlock，堆区 block ， 引用局部变量的block，ARC下 将block赋值给strong引用时。打印的block就是 NSMallocBlock

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

• NSStackBlock，栈区Block，ARC下 不将block赋值给 strong引用时。打印的block就是NSStackBlock

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

    NSLog(@"%@",block);

循环引用

循环引用.png

如图所示，A与B之间相互持有，导致两者之间都无法释放

NSString *name = @"Dragon";
self.block = ^(void){
    NSLog(@"%@",self.name);
};
self.block();

解决方法

• weak-stong-dance 强弱共舞
  • 如果block内部并未嵌套block，直接使用__weak修饰self即可

self.name = @"dragon";
    __weak typeof(self) weakSelf = self;
    self.block = ^(void){
        NSLog(@"%@",weakSelf.name);
    };
    self.block();

• 如果block内部嵌套block，需要同时使用__weak 和__strong

self.name = @"cooci";
    __weak typeof(self) weakSelf = self;
    self.block = ^(void){
    __strong typeof(weakSelf) strongSelf = weakSelf;
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            NSLog(@"%@", strongSelf.name);
        });
    };
    self.block();

• 中介者模式
  1. 手动释放

__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();

注：block必须调用，这样临时变量vc才能置空，以保证self与block的释放

2.自动释放

typedef void(^KCBlock)(ViewController *);

@property(nonatomic, copy) KCBlock block;

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

注：将对象self作为参数，提供给block内部使用，当self释放的时候对应的block也可以释放，就不会存在相互持有的问题

• NSProxy虚拟类
  OC是单继承机制，可以通过NSProxy实现伪多继承的方式
  NSProxy 和 NSObject是同级的一个类，也可以说是一个虚拟类，只是实现了NSObject的协议
NSProxy 其实是一个消息重定向封装的一个抽象类，类似一个代理人，中间件，可以通过继承它

- (id)transformObjc:(NSObject *)objc{
   _objc = objc;
    return self;
}

+ (instancetype)proxyWithObjc:(id)objc{
    return  [[self alloc] transformObjc:objc];
}

//2.有了方法签名之后就会调用方法实现
- (void)forwardInvocation:(NSInvocation *)invocation{
    SEL sel = [invocation selector];
    if ([self.objc respondsToSelector:sel]) {
        [invocation invokeWithTarget:self.objc];
    }
}

//1、查询该方法的方法签名
- (NSMethodSignature *)methodSignatureForSelector:(SEL)sel{
    NSMethodSignature *signature;
    if (self.objc) {
        signature = [self.objc methodSignatureForSelector:sel];
    }else{
        signature = [super methodSignatureForSelector:sel];
    }
    return signature;
}

- (BOOL)respondsToSelector:(SEL)aSelector{
    return [self.objc respondsToSelector:aSelector];
}

self.timer = [NSTimer timerWithTimeInterval:1 target:[DRProxy proxyWithObjc:self] selector:@selector(print) userInfo:nil repeats:YES];
    [[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

liucheng.png

虚线处变成了弱引用。于是，Controller就可以被释放掉，我们在Controller的dealloc中调用invalidate,就断掉了Runloop对Timer的引用，于是整个三个淡蓝色的就都被释放掉了。

block底层

block本质

通过底层编译查看block的实现过程

 __block NSString *lg_name = [NSString stringWithFormat:@"cooci"];
        void (^block1)(void) = ^{ // block_copy
            lg_name = @"LG_Cooci";
            NSLog(@"LG_Block - %@",lg_name);
            
            // block 内存
        };
        block1();

通过xcrun -sdk iphonesimulator clang -arch x86_64 -rewrite-objc main.m，将main.m 编译成 main.cpp，如果是仅编译.c文件也可以查看实现的过程，但是OC中特有的参数Block_byref等就没法体现

 __Block_byref_lg_name_0 lg_name =
        {(void*)0,
            (__Block_byref_lg_name_0 *)&lg_name,
            33554432,
            sizeof(__Block_byref_lg_name_0),
            __Block_byref_id_object_copy_131,
            __Block_byref_id_object_dispose_131,
            ((NSString * _Nonnull (*)(id, SEL, NSString * _Nonnull, ...))(void *)objc_msgSend)((id)objc_getClass("NSString"), sel_registerName("stringWithFormat:"), (NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_0)};
        
        void (*block1)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_lg_name_0 *)&lg_name, 570425344));
        ((void (*)(__block_impl *))((__block_impl *)block1)->FuncPtr)((__block_impl *)block1);

通过上面的编译可以得知，block调用的就是__main_block_impl_0

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

通过上述代码可知，block本质上就是一个结构体，由于block函数没有名称，也被称为匿名函数，而结构体中传入的第一个参数__main_block_func_0是一个函数，再通过赋值的方式放在 impl.FuncPtr中，这也体现出了函数式编程的一个思想

block是如何获取外界变量的

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_lg_name_0 *lg_name = __cself->lg_name; // bound by ref

            (lg_name->__forwarding->lg_name) = (NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_1;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_hr_l_56yp8j4y11491njzqx6f880000gn_T_main_9f330d_mi_2,(lg_name->__forwarding->lg_name));
        }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->lg_name, (void*)src->lg_name, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

• 未添加__block时
  __main_block_func_0中的lg_name是值拷贝，如果此时在block内部实现中作 lg_name set操作，是有问题的，会造成编译器的代码歧义，即此时的lg_name是只读的
• 添加__block后
  在__main_block_func_0内部对lg_name的处理是指针拷贝，此时创建的对象lg_name与传入对象的lg_name指向同一片内存空间

struct __Block_byref_lg_name_0 {
  void *__isa;
__Block_byref_lg_name_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);  // 5*8 = 40
 NSString *lg_name;
};

通过汇编跟进block流程

将断点下在block位置，然后查看对应的汇编，可以看出关键的流程

    0x10e375be5 <+106>: callq  0x10f47c7ea               ; symbol stub for: objc_retainBlock

    0x10d2fc45b <+219>: callq  0x10d2fc862               ; symbol stub for: objc_storeStrong


libobjc.A.dylib`objc_retainBlock:
->  0x10467ce5f <+0>: jmp    0x10467fe7a               ; symbol stub for: _Block_copy

libsystem_blocks.dylib`_Block_copy:

通过汇编可以发现是从objc_retainBlock-> _Block_copy,苹果开源网站下载最新的libclosure-74源码,通过查看_Block_copy的源码实现，发现block在底层的真正类型是Block_layout

struct Block_layout {
    //指向表明block类型的类
    void *isa;//8字节
    //用来作标识符的，类似于isa中的位域,按bit位表示一些block的附加信息
    volatile int32_t flags; // contains ref count 4字节
    //保留信息，可以理解预留位置，用于存储block内部变量信息
    int32_t reserved;//4字节
    //函数指针，指向具体的block实现的调用地址
    BlockInvokeFunction invoke;
    //block的附加信息
    struct Block_descriptor_1 *descriptor;
    // imported variables
};

• flags标识枚举

enum {
    //释放标记，一般常用于BLOCK_BYREF_NEEDS_FREE做位与运算，一同传入flags，告知该block可释放
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    //存储引用引用计数的 值，是一个可选用参数
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    //低16位是否有效的标志，程序根据它来决定是否增加或者减少引用计数位的值
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    //是否拥有拷贝辅助函数，（a copy helper function）决定block_description_2
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    //是否拥有block C++析构函数
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    //标志是否有垃圾回收，OSX
    BLOCK_IS_GC =             (1 << 27), // runtime
    //标志是否是全局block
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    //与BLOCK_HAS_SIGNATURE相对，判断是否当前block拥有一个签名，用于runtime时动态调用
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    //是否有签名
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    //使用有拓展，决定block_description_3
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};

• descriptor：block的附加信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。有三类

Block_descriptor_1是必选的
Block_descriptor_2 和 Block_descriptor_3都是可选的

// 可选
#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 {
    // requires BLOCK_HAS_COPY_DISPOSE
    BlockCopyFunction copy;
    BlockDisposeFunction dispose;
};

#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 {
    // requires BLOCK_HAS_SIGNATURE
    const char *signature;
    const char *layout;     // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};
//通过是否存在copy 和 dispose 函数进行判断 BLOCK_HAS_COPY_DISPOSE
static struct Block_descriptor_2 * _Block_descriptor_2(struct Block_layout *aBlock)
{
    if (! (aBlock->flags & BLOCK_HAS_COPY_DISPOSE)) return NULL;
    uint8_t *desc = (uint8_t *)aBlock->descriptor;
    desc += sizeof(struct Block_descriptor_1);
    return (struct Block_descriptor_2 *)desc;
}
//通过是否存在签名判断 BLOCK_HAS_SIGNATURE
static struct Block_descriptor_3 * _Block_descriptor_3(struct Block_layout *aBlock)
{
    if (! (aBlock->flags & BLOCK_HAS_SIGNATURE)) return NULL;
    uint8_t *desc = (uint8_t *)aBlock->descriptor;
    desc += sizeof(struct Block_descriptor_1);
    if (aBlock->flags & BLOCK_HAS_COPY_DISPOSE) {
        desc += sizeof(struct Block_descriptor_2);
    }
    return (struct Block_descriptor_3 *)desc;
}

通过获取block的descriptor然后根据size以及对应的结构进行内存平移进而获得Block_descriptor_2 与Block_descriptor_3

block三次copy

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// 重点提示: 这里是核心重点 block的拷贝操作: 栈Block -> 堆Block
void *_Block_copy(const void *arg) {
    struct Block_layout *aBlock;

    if (!arg) return NULL;
    
    // The following would be better done as a switch statement
    aBlock = (struct Block_layout *)arg;//强转为Block_layout类型对象，防止对外界造成影响
    if (aBlock->flags & BLOCK_NEEDS_FREE) {//是否需要释放
        // latches on high
        latching_incr_int(&aBlock->flags);
        return aBlock;
    }
    else if (aBlock->flags & BLOCK_IS_GLOBAL) {//如果是全局block，直接返回
        return aBlock;
    }
    else {//为栈block 或者 堆block，由于堆区需要申请内存，所以只可能是栈区
        // Its a stack block.  Make a copy. 它是一个堆栈块block，拷贝。
        struct Block_layout *result =
            (struct Block_layout *)malloc(aBlock->descriptor->size);//申请空间并接收
        if (!result) return NULL;
        //通过memmove内存拷贝，将 aBlock 拷贝至result
        memmove(result, aBlock, aBlock->descriptor->size); // bitcopy first
#if __has_feature(ptrauth_calls)
        // Resign the invoke pointer as it uses address authentication.
        result->invoke = aBlock->invoke;//可以直接调起invoke
#endif
        // reset refcount
        result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed 告知可释放
        result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        _Block_call_copy_helper(result, aBlock);
        // Set isa last so memory analysis tools see a fully-initialized object.
        result->isa = _NSConcreteMallocBlock;//设置block对象类型为堆区block
        return result;
    }
}

_Block_object_assign 分析

想要分析block的三层copy，首先需要知道外部变量的种类有哪些，其中用的最多的是BLOCK_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF

// CJL注释: Block 捕获的外界变量的种类
// Runtime support functions used by compiler when generating copy/dispose helpers

// Values for _Block_object_assign() and _Block_object_dispose() parameters
enum {
    // see function implementation for a more complete description of these fields and combinations
    //普通对象，即没有其他的引用类型
    BLOCK_FIELD_IS_OBJECT   =  3,  // id, NSObject, __attribute__((NSObject)), block, ...
    //block类型作为变量
    BLOCK_FIELD_IS_BLOCK    =  7,  // a block variable
    //经过__block修饰的变量
    BLOCK_FIELD_IS_BYREF    =  8,  // the on stack structure holding the __block variable
    //weak 弱引用变量
    BLOCK_FIELD_IS_WEAK     = 16,  // declared __weak, only used in byref copy helpers
    //返回的调用对象 - 处理block_byref内部对象内存会加的一个额外标记，配合flags一起使用
    BLOCK_BYREF_CALLER      = 128, // called from __block (byref) copy/dispose support routines.
};

而_Block_object_assign是在底层编译代码中，外部变量拷贝时调用的方法就是它

• 进入_Block_object_assign源码

  • 如果是普通对象，则交给系统arc处理，并拷贝对象指针，即引用计数+1，所以外界变量不能释放

  • 如果是block类型的变量，则通过_Block_copy操作，将block从栈区拷贝到堆区

  • 如果是__block修饰的变量，调用_Block_byref_copy函数 进行内存拷贝以及常规处理

static struct Block_byref *_Block_byref_copy(const void *arg) {
    
    //强转为Block_byref结构体类型，保存一份
    struct Block_byref *src = (struct Block_byref *)arg;

    if ((src->forwarding->flags & BLOCK_REFCOUNT_MASK) == 0) {
        // src points to stack 申请内存
        struct Block_byref *copy = (struct Block_byref *)malloc(src->size);
        copy->isa = NULL;
        // byref value 4 is logical refcount of 2: one for caller, one for stack
        copy->flags = src->flags | BLOCK_BYREF_NEEDS_FREE | 4;
        //block内部持有的Block_byref 和 外界的Block_byref 所持有的对象是同一个，这也是为什么__block修饰的变量具有修改能力
        //copy 和 scr 的地址指针达到了完美的同一份拷贝，目前只有持有能力
        copy->forwarding = copy; // patch heap copy to point to itself
        src->forwarding = copy;  // patch stack to point to heap copy
        copy->size = src->size;
        //如果有copy能力
        if (src->flags & BLOCK_BYREF_HAS_COPY_DISPOSE) {
            // Trust copy helper to copy everything of interest
            // If more than one field shows up in a byref block this is wrong XXX
            //Block_byref_2是结构体，__block修饰的可能是对象，对象通过byref_keep保存，在合适的时机进行调用
            struct Block_byref_2 *src2 = (struct Block_byref_2 *)(src+1);
            struct Block_byref_2 *copy2 = (struct Block_byref_2 *)(copy+1);
            copy2->byref_keep = src2->byref_keep;
            copy2->byref_destroy = src2->byref_destroy;

            if (src->flags & BLOCK_BYREF_LAYOUT_EXTENDED) {
                struct Block_byref_3 *src3 = (struct Block_byref_3 *)(src2+1);
                struct Block_byref_3 *copy3 = (struct Block_byref_3*)(copy2+1);
                copy3->layout = src3->layout;
            }
            //等价于 __Block_byref_id_object_copy
            (*src2->byref_keep)(copy, src);
        }
        else {
            // Bitwise copy.
            // This copy includes Block_byref_3, if any.
            memmove(copy+1, src+1, src->size - sizeof(*src));
        }
    }
    // already copied to heap
    else if ((src->forwarding->flags & BLOCK_BYREF_NEEDS_FREE) == BLOCK_BYREF_NEEDS_FREE) {
        latching_incr_int(&src->forwarding->flags);
    }
    
    return src->forwarding;
}

• 进入_Block_byref_copy源码

  • 将传入的对象，强转为Block_byref结构体类型对象，保存一份

  • 没有将外界变量拷贝到堆，需要申请内存，其进行拷贝

  • 如果已经拷贝过了，则进行处理并返回

  • 其中copy 和 src的forwarding指针都指向同一片内存，这也是为什么__block修饰的对象具有修改能力的原因

//********__Block_byref_id_object_copy_131********
 //block自身拷贝（_Block_copy） -- __block bref结构体拷贝(_Block_object_assign) -- _Block_object_assign中对外部变量（存储在bref）拷贝一份到内存
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
    //dst 外部捕获的变量，即结构体 - 5*8 = 40，然后就找到了lg_name(lg_name在bref初始化时就赋值了)
    _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}

 //********__Block_byref_id_object_dispose_131********
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}

三层copy总结

所以，综上所述，block的三层拷贝是指以下三层：

【第一层】通过_Block_copy实现对象的自身拷贝,从栈区拷贝至堆区

【第二层】通过_Block_byref_copy方法，将对象拷贝为Block_byref结构体类型

【第三层】调用_Block_object_assign方法，对__block修饰的当前变量的拷贝