block定义
struct Block_descriptor {
unsigned long int reserved;
unsigned long int size;
void (*copy)(void *dst, void *src);
void (*dispose)(void *);
};
struct Block_layout {
void *isa;
int flags;
int reserved;
void (*invoke)(void *, ...);
struct Block_descriptor *descriptor;
/* Imported variables. */
};
从上面代码看出，Block_layout就是对block结构体的定义：
isa指针：指向表明该block类型的类。
flags：按bit位表示一些block的附加信息，比如判断block类型、判断block引用计数、判断block是否需要执行辅助函数等。
reserved：保留变量，我的理解是表示block内部的变量数。
invoke：函数指针，指向具体的block实现的函数调用地址。
descriptor：block的附加描述信息，比如保留变量数、block的大小、进行copy或dispose的辅助函数指针。
variables：因为block有闭包性，所以可以访问block外部的局部变量。这些variables就是复制到结构体中的外部局部变量或变量的地址。
举例，定义一个最简单block 打印hello world：
int main(int argc, const char * argv[]) {
void (^block)()=^{printf("hello world");};
block();
return ;
}
使用clang指令
clang -rewrite-objc main.m
得到一个cpp文件，编译后，你就会看到什么是block了
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=) {
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
printf("hello world");
}
static struct __main_block_desc_0 {
size_t reserved;
size_t Block_size;
} __main_block_desc_0_DATA = { , sizeof(struct __main_block_impl_0)};
int main(int argc, const char * argv[]) {
void (*block)()=((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return ;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { , };
你定义完block之后，其实是创建了一个函数，在创建结构体的时候把函数的指针一起传给了block，所以之后可以拿出来调用。
再看看值捕获的问题
int main(int argc, const char * argv[]) {
int a=;
//__block int a=10; //__block前缀
void (^block)()=^{printf("打印a=%d",a);};
block();
return ;
}
定义block的时候，变量a的值就传递到了block结构体中，仅仅是值传递，所以在block中修改a是不会影响到外面的a变量的。
而加了__block前缀，编译后：
struct __Block_byref_a_0 {
void *__isa;
__Block_byref_a_0 *__forwarding;
int __flags;
int __size;
int a;
};
struct __main_block_impl_0 {
struct __block_impl impl;
struct __main_block_desc_0* Desc;
__Block_byref_a_0 *a; // by ref
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_a_0 *_a, int flags=) : a(_a->__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_a_0 *a = __cself->a; // bound by ref
printf("打印a=%d",(a->__forwarding->a));}
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->a, (void*)src->a, /*BLOCK_FIELD_IS_BYREF*/);}
static void __main_block_dispose_0(struct __main_block_impl_0*src) {_Block_object_dispose((void*)src->a, /*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 = { , sizeof(struct __main_block_impl_0), __main_block_copy_0, __main_block_dispose_0};
int main(int argc, const char * argv[]) {
__attribute__((__blocks__(byref))) __Block_byref_a_0 a = {(void*),(__Block_byref_a_0 *)&a, , sizeof(__Block_byref_a_0), };
void (*block)()=((void (*)())&__main_block_impl_0((void *)__main_block_func_0, &__main_block_desc_0_DATA, (__Block_byref_a_0 *)&a, ));
((void (*)(__block_impl *))((__block_impl *)block)->FuncPtr)((__block_impl *)block);
return ;
}
static struct IMAGE_INFO { unsigned version; unsigned flag; } _OBJC_IMAGE_INFO = { , };
并不是直接传递a的值了，而是把a的地址(&a)传过去了，所以在block内部便可以修改到外面的变量了。
isa：isa指针，在Objective-C中，任何对象都有isa指针。block 有三种类型：
_NSConcreteGlobalBlock 全局静态，不会访问任何外部变量，不会涉及到任何拷贝，比如一个空的block。例如：
#include int main()
{
^{ printf("Hello, World!\n"); } ();
return ;
}
_NSConcreteStackBlock 保存在栈中，出函数作用域就销毁，例如：
#include int main()
{
char a = 'A';
^{ printf("%c\n",a); } ();
return ;
}
_NSConcreteMallocBlock 保存在堆中，retainCount == 0销毁
该类型的block都是由_NSConcreteStackBlock类型的block从栈中复制到堆中形成的。例如下面代码中，在exampleB_addBlockToArray方法中的block还是_NSConcreteStackBlock类型的，在exampleB方法中就被复制到了堆中，成为_NSConcreteMallocBlock类型的block：
void exampleB_addBlockToArray(NSMutableArray *array) {
char b = 'B';
[array addObject:^{
printf("%c\n", b);
}];
}
void exampleB() {
NSMutableArray *array = [NSMutableArray array];
exampleB_addBlockToArray(array);
void (^block)() = [array objectAtIndex:];
block();
}
总结一下：
_NSConcreteGlobalBlock类型的block要么是空block，要么是不访问任何外部变量的block。它既不在栈中，也不在堆中，我理解为它可能在内存的全局区。
_NSConcreteStackBlock类型的block有闭包行为，也就是有访问外部变量，并且该block只且只有有一次执行，因为栈中的空间是可重复使用的，所以当栈中的block执行一次之后就被清除出栈了，所以无法多次使用。
_NSConcreteMallocBlock类型的block有闭包行为，并且该block需要被多次执行。当需要多次执行时，就会把该block从栈中复制到堆中，供以多次执行。
而ARC和MRC中，还略有不同
题目：下面代码在按钮点击后，在ARC下会发生什么，MRC下呢？为什么？
@property(nonatomic, assign) void(^block)();
- (void)viewDidLoad {
[superviewDidLoad];
int value = ;
void(^blockC)() = ^{
NSLog(@"just a block === %d", value);
};
NSLog(@"%@", blockC);
_block = blockC;
}
- (IBAction)action:(id)sender {
NSLog(@"%@", _block);
}
在ARC 打印:
mytest[:] test:<__NSMallocBlock__: 0x60000005f3e0>
mytest[:] NSShadow {, -} color = {(null)}
虽然不会crash，第二个是野指针
MRC 会打印：test:<__NSStackBlock__: 0x7fff54941a38> 然后crash
例如：
NSArray *testArr = @[@"", @""];
NSLog(@"block is %@", ^{
NSLog(@"test Arr :%@", testArr); });//结果：block is <__NSStackBlock__: 0x7fff54f3c808> void (^TestBlock)(void) = ^{
NSLog(@"testArr :%@", testArr);
};
NSLog(@"block2 is %@", TestBlock);//block2 is <__NSMallocBlock__: 0x600000045e80>
//其实上面这句在非arc中打印是 NSStackBlock, 但是在arc中就是NSMallocBlock
//即在arc中默认会将block从栈复制到堆上，而在非arc中，则需要手动copy.
循环引用
Block的循环引用是比较容易被忽视，原本也是相对比较难检查出来的问题。当然现在苹果在XCode编译的层级就已经做了循环引用的检查，所以这个问题的检查就突然变的没有难度了。
简单说一下循环引用出现的原理：Block的拥有者在Block作用域内部又引用了自己，因此导致了Block的拥有者永远无法释放内存，就出现了循环引用的内存泄漏。下面举个例子说明一下：
@interface ObjTest () {
NSInteger testValue;
}
@property (copy, nonatomic) void (^block)();
@end
@implement ObjTest
- (void)function {
self.block = ^() {
self.testValue = ;
};
}
@end
在这个例子中，ObjTest拥有了一个名字叫block的Block对象；然后在这个Block中，又对ObjTest的一个成员变量testValue进行了赋值。于是就产生了循环引用：ObjTest->block->ObjTest。
要避免循环引用的关键就在于破坏这个闭合的环。在目前只考虑ARC环境的情况下，笔者所知的只有一种方法可以破坏这个环：在Block内部对拥有者使用弱引用。
@interface ObjTest () {
NSInteger testValue;
}
@property (copy, nonatomic) void (^block)();
@end
@implement ObjTest
- (void)function {
__weak ObjTest* weakSelf = self;
self.block = ^() {
weakSelf.testValue = ;
};
}
@end
在单例模式下 Block避免循环引用,如下：
@interface Singleton : NSObject
@property (nonatomic, copy) void(^block)();
+ (instancetype)share;
@end @implementation Singleton
+ (instancetype)share {
static Singleton *singleton;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
singleton = [[Singleton alloc] init];
});
return singleton;
}
@end //============分割线=================
//控制器中代码的实现 @implementation NextViewController - (void)viewDidLoad {
[super viewDidLoad];
__weak typeof(self) weakSelf=self; void (^blockTest)()=^(){
// NSLog(@"print %@", self);//会内存泄漏
NSLog(@"print %@", weakSelf);
}; Singleton *singleton = [Singleton share];
singleton.block = blockTest;
}
- (IBAction)btnClick:(UIButton *)sender { [Singleton share].block();
} - (void)dealloc {
NSLog(@"%s", __FUNCTION__);
}
@end
为什么iOS中系统的block方法可以使用self
因为：首先循环引用发生的条件就是持有这个block的对象，被block里边加入的对象持有。当然是强引用。
所以UIView的动画block不会造成循环引用的原因就是，这是个类方法，当前控制器不可能强引用一个类，所以循环无法形成。
ARC情况下：
1、如果用copy修饰Block，该Block就会存储在堆空间。则会对Block的内部对象进行强引用，导致循环引用。内存无法释放。
解决方法：新建一个指针(__weak typeof(Target) weakTarget = Target )指向Block代码块里的对象，然后用weakTarget进行操作。就可以解决循环引用问题。
2、如果用weak修饰Block，该Block就会存放在栈空间。不会出现循环引用问题。MRC情况下用copy修饰后，如果要在Block内部使用对象，则需要进行(__block typeof(Target) blockTarget = Target )处理。在Block里面用blockTarget进行操作。
返回值类型(^block变量名)(形参列表) = ^(形参列表) {}；调用Block保存的代码block变量名(实参)；默认情况下，,Block内部不能修改外面的局部变量Block内部可以修改使用__block修饰的局部变量
参考 收藏:https://www.zhihu.com/question/30779258/answer/49492783