iOS ------ Block的相关问题

Block的定义

Block可以截获局部变量的匿名函数， 是将函数及其执行上下文封装起来的对象。

Block的实现

通过Clang将以下的OC代码转化为C++代码

// Clang
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc main.m

//main.m
#import <Foundation/Foundation.h>int main(int argc, const char * argv[]) {@autoreleasepool {void(^block)(void) = ^{NSLog(@"我是 block");};block();}return 0;
}

//参数结构体
struct __main_block_impl_0 {struct __block_impl impl;// block 结构体struct __main_block_desc_0* Desc;// block 的描述对象
/*
block 的构造函数** 返回值：__main_block_impl_0 结构体** 参数一：__main_block_func_0 结构体** 参数二：__main_block_desc_0 结构体的地址** 参数三：flags 标识位
*/__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {impl.isa = &_NSConcreteStackBlock;// &_NSConcreteStackBlock 表示存储在栈上impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};//block 结构体
struct __block_impl {void *isa;//block 的类型int Flags;int Reserved;void *FuncPtr;// block的执行函数指针，指向__main_block_func_0
};//封装了 block 中的代码
//参数是__main_block_impl_0结构体的指针
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {NSLog((NSString *)&__NSConstantStringImpl__var_folders_yx_7jg_wdg128v45l4cn_1g265h0000gn_T_main_03dcda_mi_0);}static struct __main_block_desc_0 {size_t reserved;size_t Block_size;// block 所占的内存空间
} __main_block_desc_0_DATA = { 0, sizeof(struct __main_block_impl_0)};int main(int argc, const char * argv[]) {/* @autoreleasepool */ { __AtAutoreleasePool __autoreleasepool;
/*** void(^block)(void) = ^{NSLog(@"调用了block");};** 定义block的本质：** 调用__main_block_impl_0()构造函数** 并且给它传了两个参数 __main_block_func_0 和 &__main_block_desc_0_DATA** __main_block_func_0 封装了block里的代码** 拿到函数的返回值，再取返回值的地址 &__main_block_impl_0，** 把这个地址赋值给 block*/void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
/*** block();** 调用block的本质：** 通过 __main_block_impl_0 中的 __block_impl 中的 FuncPtr 拿到函数地址，直接调用*/    ((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);}return 0;
}

void(*block)(void) = ((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));

定义block的本质：调用__main_block_impl_0()构造函数并且给它传了两个参数 __main_block_func_0 和 &__main_block_desc_0_DATA，__main_block_func_0 封装了block里的代码，拿到函数的返回值，再取返回值的地址 &__main_block_impl_0， 把这个地址赋值给 block

__main_block_impl_0

struct __main_block_impl_0 {struct __block_impl impl;// block 结构体struct __main_block_desc_0* Desc;// block 的描述对象
/*
block 的构造函数** 返回值：__main_block_impl_0 结构体** 参数一：__main_block_func_0 结构体** 参数二：__main_block_desc_0 结构体的地址** 参数三：flags 标识位
*/__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int flags=0) {impl.isa = &_NSConcreteStackBlock;// &_NSConcreteStackBlock 表示存储在栈上impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};

__block_impl

//block 结构体
struct __block_impl {void *isa;//block 的类型int Flags;int Reserved;void *FuncPtr;// block的执行函数指针，指向__main_block_func_0
};

调用block的本质：
通过 __main_block_impl_0 中的 __block_impl 中的 FuncPtr 拿到函数__main_block_func_0的地址，直接调用。

((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);

__main_block_func_0

封装了 block 中的代码，参数是__main_block_impl_0结构体的指针

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {NSLog((NSString *)&__NSConstantStringImpl__var_folders_yx_7jg_wdg128v45l4cn_1g265h0000gn_T_main_03dcda_mi_0);}

总结：
先定义block，通过__main_block_impl_0构造函数初始化__block_impl的block结构体，其中包括执行block执行函数 __main_block_func_0的地址FuncPtr。 再调用Block，转换 Block 类型为 __block_impl，通过 FuncPtr 获取执行函数地址，调用执行函数 __main_block_func_0。

Block的种类

block的分类主要分为以下的三种：

NSGlobalBlock 全局block
NSStackBlock 栈区block
NSMallocBlock 堆区block

int b = 20;- (void)viewDidLoad {[super viewDidLoad];// Do any additional setup after loading the view.static int a = 10;int c = 30;NSObject* obj = [[NSObject alloc] init];void (^Block0)(void) = ^{NSLog(@"Block");};NSLog(@"Block0  %@",Block0);void (^Block1)(void) = ^{NSLog(@"a = %d  b = %d",a, b);};NSLog(@"Block1  %@",Block1);void (^Block2)(void) = ^{NSLog(@"c = %d",c);};NSLog(@"Block2  %@",Block2);void (^Block3)(void) = ^{NSLog(@"%@",obj);};NSLog(@"Block3  %@",Block3);void (^__weak Block4)(void) = ^{NSLog(@"c = %d",c);};NSLog(@"Block4  %@",Block4);void(^block)(void);block = [Block4 copy];NSLog(@"block  %@",block);}

运行结果：

2024-07-23 21:45:38.640468+0800 Block总结[91605:3226729] Block0  <__NSGlobalBlock__: 0x104ae40d0>
2024-07-23 21:45:38.640558+0800 Block总结[91605:3226729] Block1  <__NSGlobalBlock__: 0x104ae40f0>
2024-07-23 21:45:38.640606+0800 Block总结[91605:3226729] Block2  <__NSMallocBlock__: 0x60000355a670>
2024-07-23 21:45:38.640659+0800 Block总结[91605:3226729] Block3  <__NSMallocBlock__: 0x60000357c690>
2024-07-23 21:45:38.640705+0800 Block总结[91605:3226729] Block4  <__NSStackBlock__: 0x16b31b930>
2024-07-23 21:45:38.640750+0800 Block总结[91605:3226729] block  <__NSMallocBlock__: 0x60000357c8a0>

从上面可以总结出：

GlobalBlock：

  • 位于全局变量
  • 在Block的内部不使用外部变量，或者只使用静态变量或全局变量

NSMallocBlock：

  • 在Block内部使用局部变量或者OC的属，并且赋值给强引用或者Copy修饰的变量

NSStackBlock

  • 位于栈区
  • 与mallocBlock一样，可以在内部使用局部变量或者OC属性
  • 但是不能赋值给强引用或者Copy修饰的变量

三种类型的Block的底层

  • 全局block在运行时调用_Block_copy方法后，仍然是全局block
  • 堆区block是由编译时的栈区block在运行时调用_Block_copy方法，生成新的堆区block
  • 栈区blcok不会进行_Block_copy的操作
  • 结论：如果block赋值给强引用或者copy修饰的变量，那么block会进行（objc_retainBlock中的_Block_copy操作，如果是赋值给__weak修饰的变量则不会进行_Block_copy的操作

_Block_copy方法

// Copy, or bump refcount, of a block.  If really copying, call the copy helper if present.
// 拷贝 block，
// 如果原来就在堆上，就将引用计数加 1;
// 如果原来在栈上，会拷贝到堆上，引用计数初始化为 1，并且会调用 copy helper 方法（如果存在的话）；
// 如果 block 在全局区，不用加引用计数，也不用拷贝，直接返回 block 本身
// 参数 arg 就是 Block_layout 对象，
// 返回值是拷贝后的 block 的地址
// 运行？stack -》malloc
void *_Block_copy(const void *arg) {struct Block_layout *aBlock;// 如果 arg 为 NULL，直接返回 NULLif (!arg) return NULL;// The following would be better done as a switch statement// 强转为 Block_layout 类型aBlock = (struct Block_layout *)arg;const char *signature = _Block_descriptor_3(aBlock)->signature;// 如果现在已经在堆上if (aBlock->flags & BLOCK_NEEDS_FREE) {// latches on high// 就只将引用计数加 1latching_incr_int(&aBlock->flags);return aBlock;}// 如果 block 在全局区，不用加引用计数，也不用拷贝，直接返回 block 本身else if (aBlock->flags & BLOCK_IS_GLOBAL) {return aBlock;}else {// Its a stack block.  Make a copy.// block 现在在栈上，现在需要将其拷贝到堆上// 在堆上重新开辟一块和 aBlock 相同大小的内存struct Block_layout *result =(struct Block_layout *)malloc(aBlock->descriptor->size);// 开辟失败，返回 NULLif (!result) return NULL;// 将 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;
#endif// reset refcount// 将 flags 中的 BLOCK_REFCOUNT_MASK 和 BLOCK_DEALLOCATING 部分的位全部清为 0result->flags &= ~(BLOCK_REFCOUNT_MASK|BLOCK_DEALLOCATING);    // XXX not needed// 将 result 标记位在堆上，需要手动释放；并且引用计数初始化为 1result->flags |= BLOCK_NEEDS_FREE | 2;  // logical refcount 1// copy 方法中会调用做拷贝成员变量的工作_Block_call_copy_helper(result, aBlock);// Set isa last so memory analysis tools see a fully-initialized object.// isa 指向 _NSConcreteMallocBlockresult->isa = _NSConcreteMallocBlock;return result;}
}

在这里插入图片描述

在 ARC 环境下，编译器会根据情况，自动将 Block 从栈上 copy 到堆上。具体会进行 copy 的情况有如下 4 种

  • block作为函数的返回值
  • block赋值给__strong指针，或者赋值给block类型的成员变量时
  • block作为Cocoa API方法中国呢含有using Block的方法参数
  • block作为GCDAPI的方法参数时

__block变量

在使用__block变量的Block从栈复制到堆上时，__block变量也会受到影响

按照oc的内存管理机制来管理，此时两者的关系就从block使用__block变成了block持有__block（__Block_byref_age_0结构体对象）
在这里插入图片描述

讲过的使用__block变量用结构体成员变量__forwarding的原因。“不管__block变量配置在栈上还是堆上，都能够正确访问该变量”

__block int val = 0;void (^blk) (void) = [^{++val;NSLog(@"%d", val);NSLog(@"%p", &val);} copy];++val;blk();NSLog(@"%d", val);NSLog(@"%p", &val);

输出结果：

2024-07-25 15:26:02.624764+0800 block捕获OC对象[13116:500565] 2
2024-07-25 15:26:02.625028+0800 block捕获OC对象[13116:500565] 0x600000203398
2024-07-25 15:26:02.625045+0800 block捕获OC对象[13116:500565] 2
2024-07-25 15:26:02.625055+0800 block捕获OC对象[13116:500565] 0x600000203398

在Block语法的函数中，该变量val为复制到堆上的_block变量，而使用Block语法外的与Block无关的变量val，为复制前栈上的__block变量用结构体实例。

但是栈上的__block变量用结构体实例在__block变量从栈复制到堆上时，会将成员变量__forwarding的值替换为复制目标堆上的__block变量用结构体实例的地址。

在这里插入图片描述

无论在Block语法中，Block语法外使用__block变量，还是__block变量配置在堆上或栈上，都可以顺利访问堆上同一个__block变量。

Block循环引用

循环引用的案例

typedef void(^TBlock)(void);@interface ViewController ()
@property (nonatomic, strong) TBlock block;
@property (nonatomic, copy) NSString *name;
@end@implementation ViewController- (void)viewDidLoad {[super viewDidLoad];// 循环引用self.name = @"Hello";self.block = ^(){NSLog(@"%@", self.name);};self.block();
}

这里self持有block，block也持有了self。两者的释放都要等待对方先释放。就会造成循环引用。造成内存泄露。

解决方法

  • weak的使用
    // 循环引用self.name = @"Hello";__weak typeof(self) weakSelf = self;self.block = ^(){NSLog(@"%@", weakSelf.name);};self.block();

此时self持有block，block弱引用self，强持有中断，所以不会引起循环引用。

  • 强弱共舞
self.name = @"Hello";__weak typeof(self) weakSelf = self;self.block = ^(){__strong __typeof(weakSelf)strongWeak = weakSelf;NSLog(@"%@", strongWeak.name);};self.block();

__strong的作用是防止block内部引用的外部weak变量被提前释放，进而在Block内部无法获取weak变量进而继续使用的情况。这样就保证了在block作用域结束之前，block内部都持有一个strongSelf对象可供使用。

  • 手动中断持有关系
    self.name = @"Hello";__block ViewController * ctrl = self;self.block = ^(){NSLog(@"%@", ctrl.name);ctrl = nil;};self.block();

ctrl在block使用完成后，被指为nil,block对self持有关系就解除了，不构成循环引用。

  • block传参
    // 循环引用self.name = @"Hello";self.block = ^(ViewController * ctrl){NSLog(@"%@", ctrl.name);};self.block(self);

将self作为参数传入block，进行指针拷贝，并没有对self进行持有

Block变量截获

  • 对于全局变量，不会捕获到block内部，访问方为直接访问
  • 对于auto类型的局部变量，会捕获到block内部，block内部会自动生成一个成员变量，访问方式为值传递
  • 对于static类型的局部变量，会捕获到block内部，block内部会自动生成一个成员变量，访问方式为指针传递
  • 对于对象类型的局部变量，block会连同修饰符一起捕获

auto自动变量

int main(int argc, const char * argv[]) {@autoreleasepool {int age = 10;void(^block)(void) = ^{NSLog(@"%d",age);};block();}return 0;
}

将以下 OC 代码转换为 C++ 代码

struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;int age;//生成的变量__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _age, int flags=0) : age(_age) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {int age = __cself->age; // bound by copyNSLog((NSString *)&__NSConstantStringImpl__var_folders_yx_7jg_wdg128v45l4cn_1g265h0000gn_T_main_40c716_mi_0,age);}
  • 在__main_block_impl_0结构体中会自动生成一个相同类型的age变量
  • 构造函数__main_block_impl_0中多出了一个age参数，用来捕获外部的变量

由于传递方式为值传递，所以我们在block外部修饰age变量时，不会影响到block中的age变量

static类型的局部变量

    static int age = 10;void(^block)(void) = ^{NSLog(@"%d",age);};age = 20;block();// 20

将以下OC代码转化为C++代码

struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;int *age;__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int *_age, int flags=0) : age(_age) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {int *age = __cself->age; // bound by copyNSLog((NSString *)&__NSConstantStringImpl__var_folders_yx_7jg_wdg128v45l4cn_1g265h0000gn_T_main_cb7943_mi_0,(*age));}
  • __main_block_impl_0结构体中生成了一个相同类型的age变量指针
  • __main_block_impl_0构造函数多了个参数，用来捕获外部的age变量的地址

由于传递方式是指针传递，所以修改局部变量age时，age的值会随之变化

全局变量

int height = 10;
static int age = 20;
int main(int argc, const char * argv[]) {@autoreleasepool {void(^block)(void) = ^{NSLog(@"%d,%d",height,age);};block();}return 0;
}

将以下OC代码转化为C++代码

int height = 10;
static int age = 20;struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;__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;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {NSLog((NSString *)&__NSConstantStringImpl__var_folders_yx_7jg_wdg128v45l4cn_1g265h0000gn_T_main_7a340f_mi_0,height,age);}

__main_block_impl_0结构体中，并没有自动生成age和height全局变量，也就是说没有将变量捕获到block内部

为什么局部变量需要捕获，而全局变量不用呢？

  • 作用域的原因，全局变量哪里都可以直接访问，所以不用捕获
  • 局部变量，外部不能直接访问，所以需要捕获
  • auto类型的局部变量可能会销毁，其内存会消失，block将来执行代码的时候不可能再去访问呢块内存，所以捕获其值
  • static变量会一直保存在内存中，所以捕获其地址即可

OC对象

int main(int argc, const char * argv[]) {@autoreleasepool {NSObject* obj = [[NSObject alloc] init];void(^block)(void) = ^{NSLog(@"%@", obj);};block();}return 0;
}

将以下OC代码转化为C++代码

struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;NSObject *obj;__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *_obj, int flags=0) : obj(_obj) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {NSObject *obj = __cself->obj; // bound by copyNSLog((NSString *)&__NSConstantStringImpl__var_folders_46_qzlmlhgd0xd2xjp590bfb5_00000gn_T_main_81a5a1_mi_0, obj);}
  • __main_block_impl_0结构体中生成了一个NSObject对象指针
  • __main_block_impl_0构造函数多了个参数，用来捕获外部的NSObject对象的地址（值拷贝）

_block修饰的变量

  • _block同于解决block内部无法修改auto变量值的问题；
  • _block不能修饰全局变量，静态变量；
  • 编译器会将_block变量包装成一个对象（struct __Block_byref_age_0（byref：按地址传递））；
  • 加_block修饰不会改变变量的性质，他还是auto变量；
  • 一般情况，对捕获变量进行赋值（赋值！=使用）操作需要添加_block修饰符，比如给数组添加或删除对象，就不用加_bolck修饰符；
int main(int argc, const char * argv[]) {@autoreleasepool {__block int age = 10;void(^block)(void) = ^{age = 20;NSLog(@"block-%d",age);};block();NSLog(@"%d",age);}return 0;
}
block修饰局部变量
int main(int argc, const char * argv[]) {@autoreleasepool {__block int age = 10;void(^block)(void) = ^{age = 20;NSLog(@"block-%d",age);};block();NSLog(@"%d",age);}return 0;
}

将以下OC代码转化为C++代码

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__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {__Block_byref_age_0 *age = __cself->age; // bound by ref(age->__forwarding->age) = 20;NSLog((NSString *)&__NSConstantStringImpl__var_folders_yx_7jg_wdg128v45l4cn_1g265h0000gn_T_main_75529b_mi_0,(age->__forwarding->age));}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);}static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);}
  • 编译器会将_block修饰的变量包装成一个__Block_byref_age_0结构体对象
  • 以上age = 20 的赋值过程：通过block的__main_block_imp_0结构体实例中（ __Block_byref_age_0）类型的age指针，找到 __Block_byref_age_0结构体的对象， __Block_byref_age_0结构体对象持有指向实例本身的__forwarding指针，通过成员变量_forwarding访问 __Block_byref_age_0结构体里的age变量，并将值改为20；
__block修饰对象
int main(int argc, const char * argv[]) {@autoreleasepool {__block NSObject* obj = [[NSObject alloc] init];NSLog(@"%@", obj);void(^block)(void) = ^{NSLog(@"%@", obj);obj  =  [[NSObject alloc] init];NSLog(@"%@", obj);};block();}return 0;
}

将以下OC代码转化为C++代码

struct __Block_byref_obj_0 {void *__isa;
__Block_byref_obj_0 *__forwarding;int __flags;int __size;void (*__Block_byref_id_object_copy)(void*, void*);void (*__Block_byref_id_object_dispose)(void*);NSObject *obj;
};struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;__Block_byref_obj_0 *obj; // by ref__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_obj_0 *_obj, int flags=0) : obj(_obj->__forwarding) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {__Block_byref_obj_0 *obj = __cself->obj; // bound by refNSLog((NSString *)&__NSConstantStringImpl__var_folders_46_qzlmlhgd0xd2xjp590bfb5_00000gn_T_main_155262_mi_1, (obj->__forwarding->obj));(obj->__forwarding->obj) = ((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)((NSObject *(*)(id, SEL))(void *)objc_msgSend)((id)objc_getClass("NSObject"), sel_registerName("alloc")), sel_registerName("init"));NSLog((NSString *)&__NSConstantStringImpl__var_folders_46_qzlmlhgd0xd2xjp590bfb5_00000gn_T_main_155262_mi_2, (obj->__forwarding->obj));}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->obj, (void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);}static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->obj, 8/*BLOCK_FIELD_IS_BYREF*/);}

void (__Block_byref_id_object_copy)(void, void*);

这是一个函数指针，指向一个用于复制 Block 中引用的对象的函数。当 Block 被复制到堆上（例如，通过 Block_copy）时，这个函数将被调用以确保被捕获的对象也被正确地复制。
调用后Block就持有了该对象，在栈上的时候只是使用并没有持有注意这里的对象是__Block_byref_age_0结构体对象，对于obj对象并没有持有

void (__Block_byref_id_object_dispose)(void);

这是另一个函数指针，指向一个用于释放或清理 Block 中引用的对象的函数。当 Block 被释放（例如，通过 Block_release）时，这个函数将被调用以确保被捕获的对象也被正确地释放。

总结如图

在这里插入图片描述

Block的内存管理

对外部变量的引用计数

  • 自动局部基本类型变量，因为是值传递，内存是跟随Block，不用干预
  • static局部基本类型变量，指针传递，由于分配在静态区，故不用干预
  • 全局变量，存储在数据去，不用干预
  • 局部对象变量，如果在栈上，只是使用，不用干预。但Block在拷贝到堆时，对其retain,在Block对象销毁时，对其release

示例一

  NSObject *objc = [NSObject new];NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)(objc))); // 1void(^strongBlock)(void) = ^{NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));};strongBlock();void(^__weak weakBlock)(void) = ^{NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));};weakBlock();void(^mallocBlock)(void) = [weakBlock copy];mallocBlock();

输出结果：

2024-07-24 09:46:10.696422+0800 Block总结[5902:3676907] 1
2024-07-24 09:46:10.696469+0800 Block总结[5902:3676907] ---3
2024-07-24 09:46:10.696501+0800 Block总结[5902:3676907] ---4
2024-07-24 09:46:10.696542+0800 Block总结[5902:3676907] ---5

为什么第二个打印3
我们可以看一看这段源码

struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;NSObject *obj;__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, NSObject *_obj, int flags=0) : obj(_obj) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {NSObject *obj = __cself->obj; // bound by copyNSLog((NSString *)&__NSConstantStringImpl__var_folders_46_qzlmlhgd0xd2xjp590bfb5_00000gn_T_main_81a5a1_mi_0, obj);}

编译时这段直接捕获局部OC对象，将obj指针拷贝过来并且赋值，引用计数加一。运行时block还会从栈区拷贝到堆区，obj的引用计数还会加一

示例二

 __block NSObject *objc = [[NSObject alloc] init];NSLog(@"%@",objc);NSLog(@"%ld",CFGetRetainCount((__bridge CFTypeRef)(objc))); // 1void(^strongBlock)(void) = ^{NSLog(@"%@",objc);NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));NSObject* objc1 = objc;NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));};strongBlock();NSLog(@"---%ld",CFGetRetainCount((__bridge CFTypeRef)(objc)));

输出结果

2024-07-24 20:59:00.137761+0800 block捕获OC对象[8663:256819] <NSObject: 0x600000008050>
2024-07-24 20:59:00.137770+0800 block捕获OC对象[8663:256819] 1
2024-07-24 20:59:00.137780+0800 block捕获OC对象[8663:256819] <NSObject: 0x600000008050>
2024-07-24 20:59:00.137788+0800 block捕获OC对象[8663:256819] ---1
2024-07-24 20:59:00.137795+0800 block捕获OC对象[8663:256819] ---2
2024-07-24 20:59:00.137802+0800 block捕获OC对象[8663:256819] ---1

为什么第二个输出1？
先看一下源码

struct __Block_byref_obj_0 {void *__isa;
__Block_byref_obj_0 *__forwarding;int __flags;int __size;void (*__Block_byref_id_object_copy)(void*, void*);void (*__Block_byref_id_object_dispose)(void*);NSObject *obj;
};struct __main_block_impl_0 {struct __block_impl impl;struct __main_block_desc_0* Desc;__Block_byref_obj_0 *obj; // by ref__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_obj_0 *_obj, int flags=0) : obj(_obj->__forwarding) {impl.isa = &_NSConcreteStackBlock;impl.Flags = flags;impl.FuncPtr = fp;Desc = desc;}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {__Block_byref_obj_0 *obj = __cself->obj; // bound by ref}

编译器会将_block修饰的变量包装成一个__Block_byref_age_0结构体对象

__Block_byref_obj_0 *obj = __cself->obj;

当块捕获 __block 变量时，它实际上捕获的是 __Block_byref 结构体的指针，而不是变量本身。这意味着块捕获的是指向 __block 变量的间接引用，而不是直接引用

__block 修饰符时，编译器会对该变量进行特殊处理：
__block 变量在栈上分配内存。
当块（block）被复制到堆上时，__block 变量的内存也会被复制到堆上。

Block堆栈释放差异

#pragma mark - block 堆栈释放差异
- (void)jpreno {int reno = 10;void(^__weak weakBlock)(void) = nil;{// 栈区void(^__weak strongBlock)(void) = ^{NSLog(@"jp1:---%d", reno);};weakBlock = strongBlock;NSLog(@"jp2:--%@--%@",weakBlock,strongBlock);}weakBlock();}

输出结果

2024-07-24 11:08:23.993541+0800 Block总结[7484:3735630] jp2:--<__NSStackBlock__: 0x16b9939b0>--<__NSStackBlock__: 0x16b9939b0>
2024-07-24 11:08:23.993625+0800 Block总结[7484:3735630] jp1:---10

通过赋值weakBlock = strongBlock操作，两个block同时指向一个NSStackBlock，代码块运行结束后不会被释放，能够正常运行 weakBlock();

        int reno = 10;void(^__weak weakBlock)(void) = nil;{// 栈区void(^__strong strongBlock)(void) = ^{NSLog(@"jp1:---%d", reno);};weakBlock = strongBlock;NSLog(@"jp2:--%@--%@",weakBlock,strongBlock);}weakBlock();

由于weakBlock不能强引用NSMallocBlock，代码块运行结束就会被释放。此时调用weakBlock()指向的对象已经被释放了，形成野指针，所以程序崩溃了。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/50468.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

3.2、数据结构-数组、矩阵和广义表

3.2、数据结构-数组、矩阵和广义表

数组结构 数组是定长线性表在维度上的扩展,即线性表中的元素又是一个线性表。N维数组是一种“同构”的数据结构,其每个数据元素类型相同、结构一致。 一个m行n列的数组表示如下: 其可以表示为行向量形式&#xff08;一行一行的数据&#xff09;或者列向量形式&#xff08;一…
阅读更多...
Nginx 怎样处理请求的故障转移？

Nginx 怎样处理请求的故障转移？

&#x1f345;关注博主&#x1f397;️ 带你畅游技术世界&#xff0c;不错过每一次成长机会&#xff01; 文章目录 Nginx 怎样处理请求的故障转移&#xff1f;一、理解故障转移的重要性二、Nginx 中的故障检测机制三、Nginx 中的请求分配策略四、Nginx 中的故障转移实现方式五、…
阅读更多...
Shell脚本编程（一）

Shell脚本编程（一）

目录 一、Shell命令行的书写规则 二、编写/修改权限及执行shell程序的步骤 1、编写简单Shell程序 2、建立可执行程序 3、执行Shell程序 4、实例 三、Shell程序中使用参数 1、位置参数 2、内部参数 3、实例一 4、实例二 一、Shell命令行的书写规则 在执行Shell命令时…
阅读更多...
搭建本地私有知识问答系统：MaxKB + Ollama + Llama3 （wsl网络代理配置、MaxKB-API访问配置）

搭建本地私有知识问答系统：MaxKB + Ollama + Llama3 （wsl网络代理配置、MaxKB-API访问配置）

目录 搭建本地私有知识问答系统：MaxKB、Ollama 和 Llama3 实现指南引言MaxKB+Ollama+Llama 3 Start buildingMaxKB 简介：1.1、docker部署 MaxKB（方法一）1.1.1、启用wls或是开启Hyper使用 WSL 2 的优势1.1.2、安装docker1.1.3、docker部署 MaxKB (Max Knowledge Base)MaxKB …
阅读更多...
便携式气象仪：科技赋能，让气象观测更智能

便携式气象仪：科技赋能，让气象观测更智能

随着科技的快速发展&#xff0c;越来越多的领域受益于技术的进步。其中&#xff0c;气象观测领域也不例外。传统的气象观测设备虽然精确可靠&#xff0c;但往往体积庞大、携带不便&#xff0c;且需要专业人员进行操作和维护。而便携式气象仪的出现&#xff0c;则打破了这一局限…
阅读更多...
在WPF中使用WebView2详解

在WPF中使用WebView2详解

Microsoft Edge WebView2 Microsoft Edge WebView2 控件允许在本机应用中嵌入 web 技术(HTML、CSS 以及 JavaScript)。 WebView2 控件使用 Microsoft Edge 作为绘制引擎&#xff0c;以在本机应用中显示 web 内容。 使用 WebView2 可以在本机应用的不同部分嵌入 Web 代码&…
阅读更多...
Golang | Leetcode Golang题解之第284题窥视迭代器

Golang | Leetcode Golang题解之第284题窥视迭代器

题目&#xff1a; 题解&#xff1a; type PeekingIterator struct {iter *Iterator_hasNext bool_next int }func Constructor(iter *Iterator) *PeekingIterator {return &PeekingIterator{iter, iter.hasNext(), iter.next()} }func (it *PeekingIterator) hasNe…
阅读更多...
学习记录day19——数据结构 查找算法

学习记录day19——数据结构 查找算法

概念 在给定数据元素的某个值&#xff0c;在查找表中确定一个其关键字等于给定值的数据元素的操作&#xff0c;叫做查找 查找的分类 顺序查找:将待查找数据&#xff0c;进行全部遍历一遍&#xff0c;直到找到要查找的元素 折半查找:每次都去除一半的查找范围的查找方式&#x…
阅读更多...
vue3响应式用法（高阶性能优化）

vue3响应式用法（高阶性能优化）

文章目录 前言&#xff1a;一、 shallowRef()二、 triggerRef()三、 customRef()四、 shallowReactive()五、 toRaw()六、 markRaw()七、 shallowReadonly()小结&#xff1a; 前言&#xff1a; 翻别人代码时&#xff0c;总结发现极大部分使用vue3的人只会用ref和reactive处理响…
阅读更多...
mysql-bin 恢复数据库

mysql-bin 恢复数据库

能看到这里的同学估计肯定摊上大事了吧&#xff01;不要慌&#xff0c;一定要冷静&#xff0c;记录一下作者的大事件吧&#xff0c;黑客通过SQL注入的方式执行了一段SQL &#xff1a; DROP DATABASE ****** 后果就是导致整个数据库被删了&#xff0c;当时心是拔凉拔凉的&#x…
阅读更多...
在jmeter中使用javascript脚本

在jmeter中使用javascript脚本

工作上遇到一个压力测试的需求&#xff0c;需要测试几个考试相关的接口。其中有一个获取试题详情的接口&#xff0c;和一个提交答题信息的接口。后一个接口以上一接口的返回内容为参数&#xff0c;添加上用户的答案即可。jmeter提供了非常多的方式可以实现该需求&#xff0c;这…
阅读更多...
【深度学习】大模型GLM-4-9B Chat ，微调与部署(3) TensorRT-LLM、TensorRT量化加速、Triton部署

【深度学习】大模型GLM-4-9B Chat ，微调与部署(3) TensorRT-LLM、TensorRT量化加速、Triton部署

文章目录 获取TensorRT-LLM代码&#xff1a;构建docker镜像并安装TensorRT-LLM&#xff1a;运行docker镜像&#xff1a;安装依赖魔改下部分package代码&#xff1a;量化&#xff1a;构建图&#xff1a;全局参数插件配置常用配置参数 测试推理是否可以代码推理CLI推理 性能测试小…
阅读更多...
钡铼网关实时数据互联，加速IEC104与MQTT云平台对接

钡铼网关实时数据互联，加速IEC104与MQTT云平台对接

随着工业4.0时代的到来&#xff0c;电力系统中的数据采集、监控与远程控制需求日益增长。IEC 104&#xff08;IEC 60870-5-104&#xff09;作为国际电工委员会&#xff08;IEC&#xff09;制定的电力自动化通信协议&#xff0c;广泛应用于电力系统的状态监测、数据采集和设备控…
阅读更多...
Vue实现简单小案例

Vue实现简单小案例

一、创建文件夹 二、引用vue.js <script src"../js/vue.js"></script> 三、准备一个容器 <div id"app"><h1>Hello,{{name}}</h1> </div> 四、创建实例 <script>new Vue({el:"#app", //el用于指…
阅读更多...
【STM32 FreeRTOS】FreeRTOS的移植

【STM32 FreeRTOS】FreeRTOS的移植

其实这篇文章不侧重移植&#xff0c;因为我们会使用CubeMX配置&#xff0c;那样会自动移植FreeRTOS。 关于FreeRTOS&#xff0c;可以参考官网&#xff1a;FreeRTOS - Quick start guide 当我们在CubeMX中配置了CMSIS_V2后尝试编译的时候会有一个弹窗。 第一个问题就是强烈建议…
阅读更多...
【深度学习】yolov8-det目标检测训练，拼接图的分割复原

【深度学习】yolov8-det目标检测训练，拼接图的分割复原

项目背景 https://blog.csdn.net/x1131230123/article/details/140606459 似乎这个任务是简单的&#xff0c;利用目标检测是否可以完成得好呢? 生成数据集 利用这个代码产生数据集&#xff1a; 为了将标签转换为YOLOv5格式&#xff0c;需要将左上角和右下角的坐标转换为Y…
阅读更多...
【性能测试-登录时密码加密存储如何传参】

【性能测试-登录时密码加密存储如何传参】

目的】 登录接口&#xff0c;密码加密传输&#xff0c;开发不做处理的情况下&#xff0c;密码如何加密传输 【方案】 使用前置处理器&#xff1a;JSR223 预处理程序&#xff0c;主要是在执行登录接口前将密码按照加密算法获得对应的加密密码&#xff0c;并传入接口 【说明】前…
阅读更多...
如何对视频文件加密_如何加密视频文件_视频文件如何加密

如何对视频文件加密_如何加密视频文件_视频文件如何加密

“嘿&#xff0c;小李&#xff0c;你知道咱们公司的新项目资料都是视频形式的吗&#xff1f;这些视频里有很多机密信息&#xff0c;我们需要好好保护起来。” “是啊&#xff0c;我也在想这个问题。你有没有什么好办法来加密这些视频文件呢&#xff1f;” “我听说有个叫域智盾…
阅读更多...
生成式AI的双重路径：Chat与Agent的融合与竞争

生成式AI的双重路径：Chat与Agent的融合与竞争

文章目录 每日一句正能量前言整体介绍对话系统&#xff08;Chat&#xff09;自主代理&#xff08;Agent&#xff09;结论 技术对比技术差异优势与劣势技术挑战结论 未来展望发展趋势Chat与Agent的前景社会和经济影响结论 后记 每日一句正能量 在避风的港湾里&#xff0c;找不到…
阅读更多...
代码随想录算法训练营第38天|LeetCode 322. 零钱兑换、279.完全平方数、139.单词拆分

代码随想录算法训练营第38天|LeetCode 322. 零钱兑换、279.完全平方数、139.单词拆分

1. LeetCode 322. 零钱兑换 题目链接&#xff1a;https://leetcode.cn/problems/coin-change/description/ 文章链接&#xff1a;https://programmercarl.com/0322.零钱兑换.html 视频链接&#xff1a;https://www.bilibili.com/video/BV14K411R7yv/ 思路&#xff1a; 硬币无限…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023