最简单用法：
void (^block)(void) = ^{
NSLog(@"this is block");
NSLog(@"this is block");
NSLog(@"this is block");
NSLog(@"this is block");
};
block();
- block本质上也是一个OC对象，它内部也有个isa指针
- block是封装了函数调用以及函数调用环境的OC对象
-
block的底层结构如图所示block底层结构
int age = 10;
void (^block)() = ^(){
NSLog(@"Hello，world！%d",age);
};//创建block的时候，已经把age的值捕获(capture)进来,(变量捕获)
age = 20;
block();
打印结果：
Hello，world！10
block的变量捕获（capture）
-
为了保证block内部能够正常访问外部的变量，block有个变量捕获机制
block访问局部变量：
int age = 10;
//默认有个auto关键字，其实等价于auto int age = 10;
//auto的意思是离开当前的大括号，变量自动销毁，
//auto：自动变量，离开作用域就销毁，所以auto只存在于局部变量
static int height = 10;
void (^block)(void) = ^(){
NSLog(@"age is %d,height is %d",age,height);
};
age = 20;
height = 20;
block();
打印结果：
age is 10,height is 20
那么为什么auto和static修饰的变量会有这个区别呢？
因为auto修饰的变量可能会在内存中销毁，那么block不能去访问那块内存，
block访问全局变量：
#import <Foundation/Foundation.h>
int age_ = 10;
static int height_ = 10;
int main(int argc, const char * argv[]) {
@autoreleasepool {
void (^block)(void) = ^(){
NSLog(@"age is %d,height is %d",age_,height_);
};
age_ = 20;
height_ = 20;
block();
}
return 0;
}
打印结果：
age is 20,height is 20
cpp编译代码
所以，全局变量不需要捕获，直接访问就可以。
那么局部变量为什么需要捕获呢？
作用域的问题，跨函数访问局部变量，需要捕获
涉及到会不会捕获的问题：先搞清楚是局部变量还是全局变量。全局变量不会捕获，局部变量会捕获
Person.m文件
例子1:
- (void)test{
void (^block)(void) = ^{
NSLog(@"--------%p",self);
};
block();
//self需要捕获到block里边吗？
//会捕获，self是局部变量，在c++函数test函数是默认传了两个参数，相当于void test(Person *self,SEL _cmd),参数是一种局部变量，所以会被捕获
}
例子2:
- (void)test{
void (^block)(void) = ^{
NSLog(@"--------%p",_name);
};
//_name来自于self->_name,来自于方法调用者，
//所以只能先捕获self对象，然后再访问self里边的属性
block();
}
例子3：
- (void)test{
void (^block)(void) = ^{
NSLog(@"--------%p",[self name]);
};
//先捕获self对象，然后再访问self里边的属性
block();
}
例子4:
#import "Person.h"
@implementation Person
int age_ = 10;
- (void)test{
void (^block)(void) = ^{
NSLog(@"--------%d",age_);
};
block();
}//全局变量不需要捕获
@end
Block类型
- block有3种类型，可以通过调用class方法或者isa指针查看具体类型，最终都是继承自NSBlock类型
1.NSGlobalBlock (_NSConcreteGlobalBlock)
2.NSStackBlock(_NSConcreteStackBlock)
3.NSMallocBlock(_NSConcreteMallocBlock)
void (^block1)(void) = ^{
NSLog(@"Hello");
};
int age = 10;
void (^block2)(void) = ^{
NSLog(@"Hello - %d",age);
};
NSLog(@"%@ : %@ : %@",[block1 class],[block2 class],[^{
NSLog(@"%d",age);
} class]);
打印结果：
__NSGlobalBlock__ : __NSMallocBlock__ : __NSStackBlock__
用clang编译的c++文件写的isa都是&_NSConcreteStackBlock 类型，
这里需要注意一点就是：一切以运行时的结果为准，
clang c++生成的文件有的时候只能作为参考
应用程序的内存分配
如何判断block是哪种类型的？
void (^block1)(void) = ^{
NSLog(@"block1----");
};
NSLog(@"%@",[block1 class]);
打印结果：
__NSGlobalBlock__
int a = 10;
void (^block1)(void) = ^{
NSLog(@"block1----%d",a);
};
NSLog(@"%@",[block1 class]);
打印结果：
__NSMallocBlock__
（这里为什么和上面的图片不一样呢，访问了auto变量，不是应该是__NSStackBlock__类型么？这里需要注意把arc关闭，因为arc做了好多事情，关闭如下图所示，关掉之后再build一次。）
打印结果：
__NSStackBlock__
关闭arc
void (^block)(void);
void test2()
{
int age = 10;
block = ^{
NSLog(@"block-----%d",age);
};
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
test2();
block();
打印结果：
block-----67940808
乱码原因：block访问了auto变量所以是__NSStackBlock__，保存在栈内存中，test2()函数调用完，栈内存中的数据就被释放了，所以如果想不被释放，就要把block变成__NSMallocBlock__，即__NSStackBlock__调用copy就升级为__NSMallocBlock__
}
return 0;
}
NSStackBlock调用copy就升级为NSMallocBlock代码如下：
void (^block)(void);
void test2()
{
int age = 10;
block = [^{
NSLog(@"block-----%d",age);
} copy];
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
test2();
block();
打印结果：block-----10
}
return 0;
}
-
每一种类型的block调用copy后的结果如下所示：
插播：想知道类对象存在哪里，如下试验
int age = 10;
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
int a = 20;
NSLog(@"age %p",&age);
NSLog(@"a %p",&a);
NSLog(@"obj %p",[[NSObject alloc] init]);
NSLog(@"class %p",[Person class]);
打印结果：
age 0x100008204（数据段）
a 0x3040cb20c （栈）
obj 0x108e154e0 （堆）
class 0x1000081a8 （和age的地址很相似，所以存在于数据段）
}
return 0;
}
block的copy
- 在ARC环境下，编译器会根据情况自动将栈上的block复制到堆上，比如以下情况：
1.block作为函数返回值时,代码示例如下：
typedef void(^Block)(void);
Block myblock()
{
int age = 10;
return ^{
NSLog(@"-------%d",age);
};
}
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
Block block = myblock();
block();
NSLog(@"class = %@",[block class]);
打印结果：
-------10
class = __NSMallocBlock__
}
return 0;
}
2.将block赋值给__strong指针时
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
Block block = ^{
NSLog(@"---%d",age);
};
NSLog(@"class = %@",[block class]);
}
return 0;
}
ARC环境下打印结果：
class = __NSMallocBlock__
MRC环境下打印结果：
class = __NSStackBlock__
如果把上边的代码换成如下没有强指针指向，就不会自动将block复制到堆上。
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
// Block block = ^{
// NSLog(@"---%d",age);
// };
NSLog(@"class = %@",[^{
NSLog(@"---%d",age);
} class]);
}
return 0;
}
ARC环境下打印结果：
class = __NSStackBlock__
3.block作为Cocoa API中方法名含有usingBlock的方法参数时
NSArray *array = @[];
[array enumerateObjectsUsingBlock:^(id _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
}];
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
对象类型的auto变量
- 当block内部访问了对象类型的
auto变量时
- 如果block是在栈上，将不会对auto变量产生强引用
- 如果block被拷贝到堆上：会调用block内部的copy函数；copy函数内部会调用_Block_object_assign函数； _Block_object_assign函数会根据auto变量的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，类似于retain（形成强引用、弱引用）
- 如果block从堆上移除：会调用block内部的dispose函数；dispose函数内部会调用_Block_object_dispose函数；_Block_object_dispose函数会自动释放引用的auto变量，类似于release
__weak问题解决
- 在使用clang转换为OC为C++代码时，可能会遇到以下问题：cannot create __weak reference in file using manual reference
- 解决方案：支持ARC、指定运行时系统版本，比如：
xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m
__block修饰符
int main(int argc, const char * argv[]) {
@autoreleasepool {
int age = 10;
Block block = ^{
age = 20;
//报错：Variable is not assignable (missing __block type specifier)
//报错，默认情况下，block是不能修改外面的值的
NSLog(@"age is %d",age);
};
block();
}
return 0;
}
如果block想修改外面的值，那么可以把外面的值的属性用static修饰，写法如下：
int main(int argc, const char * argv[]) {
@autoreleasepool {
static int age = 10;
Block block = ^{
age = 20;
NSLog(@"age is %d",age);
};
block();
}
return 0;
}
或者把局部变量设置为全局变量，写法如下：
int age = 10;
int main(int argc, const char * argv[]) {
@autoreleasepool {
Block block = ^{
age = 20;
NSLog(@"age is %d",age);
};
block();
}
return 0;
}
还有一种方法是用__block，（因为如果我只是想临时用变量，static修饰的变量或者全局变量会一直存在内存中），写法如下：
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block int age = 10;
Block block = ^{
age = 20;
NSLog(@"age is %d",age);
};
block();
}
return 0;
}
-
__block可以用于解决block内部无法修改auto变量值的问题 -
__block不能修饰全局变量、静态变量（static） - 编译器会将
__block变量包装成一个对象
__block的内存管理
- 当block在栈上时，并不会对__block变量产生强引用
-
当block被copy到堆时：会调用block内部的copy函数；copy函数内部会调用_Block_object_assign函数；_Block_object_assign函数会对__block变量形成强引用（retain）
-
当block从堆中移除时：会调用block内部的dispose函数；dispose函数内部会调用_Block_object_dispose函数；_Block_object_dispose函数会自动释放引用的__block变量（release）
对象类型的auto变量、__block变量
- 当block在栈上时，对它们都不会产生强引用
- 当block拷贝到堆上时，都会通过copy函数来处理它们
__block变量（假设变量名叫做a）：_Block_object_assign((void )&dst->a,(void )src->a,8/BLOCK_FIELD_IS_BYREF/);
对象类型的auto变量（假设变量名叫做p）
_Block_object_assign((void )&dst->p,(void )src->p,3/BLOCK_FIELD_IS_OBJECT/); - 当block从堆上移除时，都会通过dispose函数来释放它们
__block变量（假设变量名叫做a）：
_Block_object_dispose((void )src->a,8/BLOCK_FIELD_IS_BYREF/);
对象类型的auto变量（假设变量名叫做p）
_Block_object_dispose((void )src->p,3/BLOCK_FIELD_IS_OBJECT/);
__block的__forwarding指针
被__block修饰的对象类型
- 当__block变量在栈上时，不会对指向的对象产生强引用
- 当__block变量被copy到堆时：会调用__block变量内部的copy函数；copy函数内部会调用_Block_object_assign函数；_Block_object_assign函数会根据所指向对象的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用（注意：这里仅限于ARC时会retain，MRC时不会retain）
- 如果__block变量从堆上移除：会调用__block变量内部的dispose函数；dispose函数内部会调用_Block_object_dispose函数；_Block_object_dispose函数会自动释放指向的对象（release）
block的循环引用的问题
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.age = 10;
person.block = ^{
NSLog(@"age is----%d",person.age);
};
}
NSLog(@"11111111");
return 0;
}
解决循环引用问题 - ARC
- 用__weak、__unsafe_unretained解决,
__weak:不会产生强引用，指向的对象销毁时，会自动让指针置为nil
__unsafe_unretained :不会产生强引用，不安全，指向的对象销毁时，指针存储的地址值不变。（不常用）
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
Person *person = [[Person alloc] init];
person.age = 10;
__weak Person *weakPerson = person;
//或者下边的写法：
// __weak typeof(person) weakPerson = person;
//或者
//__unsafe_unretained Person *weakPerson = person;
person.block = ^{
NSLog(@"age is----%d",weakPerson.age);
};
}
NSLog(@"11111111");
return 0;
}
- 用__block解决（必须要调用block）
#import <Foundation/Foundation.h>
#import "Person.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
__block Person *person = [[Person alloc] init];
person.age = 10;
person.block = ^{
NSLog(@"age is----%d",person.age);
person = nil;
};
person.block();
}
return 0;
}
解决循环引用问题 - MRC
MRC不支持__weak的
-
用__unsafe_unretained解决
-
用__block解决
