####参考
Block编译代码解读： block没那么难（一、二、三） iOS进阶——iOS（Objective-C） 内存管理&Block
Block源码解读: 漫谈Block 苹果爹爹Block实现源码
####一、Block代码 (1) 没有返回值、没有参数的block
void (^voidBlock)() = ^{};
voidBlock();
复制代码(2) 没有返回值、有一个参数的block
void (^parameterBlock)(NSInteger parameter) = ^(NSInteger parameter){
NSLog(@"=====parameterBlock");
};
parameterBlock(1);
复制代码(3)没有返回值、有两个参数的block
void (^parametersBlock)(int par1, int par2) = ^(int par1, int par2){
NSLog(@"=====parameterBlock");
};
parametersBlock(2,3);
复制代码(4) 有返回值、有参数的block
NSString *(^returnBlock)(NSInteger a) = ^(NSInteger a){
return @"returnBlock";
};
NSLog(@"=====%@",returnBlock);
复制代码(5) block的typedef定义、使用
typedef void(^TypedefBlock)(NSInteger type);
TypedefBlock typedefBlock = ^(NSInteger type){
NSLog(@"TypedefBlock");
};
typedefBlock(1);
复制代码####二、Block的类型，什么是NSGlobalBlock、NSStackBlock、NSMallocBlock？ ######1、NSGlobalBlock （1）没有捕获外部变量
void(^blockA)(void) = ^() {
NSLog(@"=====%@",@"asdasd");
};
NSLog(@"=====%@",blockA); // <__NSGlobalBlock__: 0x10debd190>
复制代码（2）只捕获全局变量,全局静态变量,局部静态变量。
int b = 20; // 全局变量
static int c = 30;// 全局静态变量
- (void)viewDidLoad {
[super viewDidLoad];
static int a = 10; // 局部静态变量
void(^blockA)(void) = ^() {
a++;
b++;
c++;
};
NSLog(@"=====%@",blockA); // <__NSGlobalBlock__: 0x10af19190>
}
复制代码另外：GlobalBlock的copy与retain还是GlobalBlock
######(2) NSStackBlock:使用了外部变量的block,将 Block 赋值给附有 __weak 修饰符变量。栈区
int a = 10;
typedef void (^BBBlock)();
__weak BBBlock aBlock = ^(){
NSLog(@"a = %i",a);
};
NSLog(@"=====%@",^{NSLog(@"a = %i",a);}); // ====<__NSStackBlock__: 0x7fff50af3ce0>
NSLog(@"=====%@",aBlock); // =====<__NSStackBlock__: 0x7fff50af3d08>
复制代码######(3) NSMallocBlock:有以下几种情况 1、[stackBlock copy]；stackBlock的copy方法; 2、return stackBlock；stackBlock作为返回值; 3、将stackBlock赋值给附有 __strong 修饰符的成员变量; 4、在方法名中含有 usingBlock 的 Cocoa 框架方法或 GCD 的 API 中传递stackBlock，方法里面先Block block = [stackBlock copy],然后使用block
[stackBlock copy]
int a = 10;
typedef void (^BBBlock)();
__weak BBBlock stackBlock = ^(){
NSLog(@"a = %i",a);
};
BBBlock block1 = [stackBlock copy];
NSLog(@"=====%@",block1);// <__NSMallocBlock__: 0x60000045d8b0>
复制代码stackBlock做返回值
//返回值是stackBlock的，变成NSMallocBlock
- (void(^)())getBlock {
int a = 0;
return ^{NSLog(@"=====%d",a);};
}
NSLog(@"%@",[self getBlock]);// <__NSMallocBlock__: 0x60000045d8b0>
复制代码将stackBlock赋值给附有 __strong 修饰符的成员变量时,(变量默认修饰符是__strong)
int a = 2;
void(^aBlock)() = ^{
NSLog(@"a=%ld",(long)a);
};
NSLog(@"=====%@", aBlock);// <__NSMallocBlock__: 0x60000045d8b0>
复制代码####三、block捕捉变量，有__block修饰、无_block修饰到底发生了什么？ __block 修饰局部变量obj，是包装成一个__Block_byref_XXX_n的对象obj，当这个结构体被block使用且block_copy上堆时候，__Block_byref obj也会被复制到堆上。
__block NSObject *obj = [NSObject new]; 代码级别使用obj的地方编译为：obj.__forwarding->obj
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*);
NSString *obj;
};
复制代码首先，了解一下内存分配 iOS开发中的内存分配（堆和栈）
（1）栈（stack）：由编译器自动分配释放，存放方法的参数值，局部变量等。栈是向低地址括展的数据结构，是连续的区域。栈顶的地址和栈的最大容量是系统预先规定好的。 优点：快速高效， 缺点：容量有限制 静态分配：静态分配是编译器完成的，比如局部变量的分配。 动态分配：动态分配由alloca函数进行分配，由编译器进行释放，无需我们手工实现。 （2）堆（heap）：程序员分配释放，向高地址括展的数据结构，是不连续的区域。 （3）全局区（静态区）（static）：全局变量和静态变量的存储，分初始化和未初始化bss（data、bss 两块区域），程序结束系统释放。 （4）常量区：字符串常量，const常量，程序结束系统释放。 （5）代码区：存放函数体的二进制代码。也就是说是它是可执行程序在内存种的镜像。代码段需要防止在运行时被非法修改，所以只准许读取操作，而不允许写入（修改）操作——它是不可写的。
看代码
int age = 24;//全局初始化区（数据区）
NSString *name;//全局未初始化区（BSS区）
static NSString *sName = @"Dely";//指针sName的地址在全局（静态初始化）区，"Dely"本身在常量去，字符串常量
@implementation ViewController
- (void)viewDidLoad {
[super viewDidLoad];
int tmpAge;//栈
NSString *tmpName = @"Dely"; //指针tmpName的地址在栈区，"Dely"本身在常量去，字符串常量
NSString *number = @"123456"; //指针number的地址在栈上，123456 在常量区，
NSMutableArray *array = [NSMutableArray arrayWithCapacity:1];//分配而来的8字节的区域就在堆中，指针array在栈中，指向堆区的地址
NSInteger total = [self getTotalNumber:1 number2:1];
}
- (NSInteger)getTotalNumber:(NSInteger)number1 number2:(NSInteger)number2{
return number1 + number2;//number1和number2 栈区
}
复制代码1、局部变量
######（1）无_block修饰： 基本类型
int a = 10;
NSLog(@"block定义前a地址=%p", &a);
void (^aBlock)() = ^(){
NSLog(@"block定义内部a地址=%p", &a);
};
NSLog(@"block定义后a地址=%p", &a);
aBlock();
/*
结果：
block定义前a地址=0x7fff5bdcea8c
block定义后a地址=0x7fff5bdcea8c
block定义内部a地址=0x7fa87150b850
*/
/*
流程：
1. block定义前：a在栈区
2. block定义内部：里面的a是根据外面的a拷贝到堆中的，不是一个a，
3. block定义后：a在栈区
*/
复制代码指针类型：(block捕获变量，相当于在block结构体中开一个同名的变量，指向局部变量的对象，被block持有，引用数+1)
NSObject *obj = [[NSObject alloc] init]; // 局部变量--指针变量，多提一下：“=”赋值右边的（alloc init）分配的地址是在堆上，左边obj指针地址是在栈上
NSLog(@"block定义前:[obj本身的地址=%p,obj指向的地址=%p]",&obj,obj);
void (^aBlock)() = ^(){
NSLog(@"block定义内部:[obj本身的地址=%p,obj指向的地址=%p]",&obj,obj);
};
NSLog(@"block定义后:[obj本身的地址=%p,obj指向的地址=%p]",&obj,obj);
aBlock();
/*
NSLog输出：
block定义前:[obj本身的地址=0x7fff5bebed30,obj指向的地址=0x60000001f750]
block定义后:[obj本身的地址=0x7fff5bebed30,obj指向的地址=0x60000001f750]
block定义内部:[obj本身的地址=0x600000059910,obj指向的地址=0x60000001f750]
*/
/*
解析：
1. block定义前：指针obj本身的地址在栈区，指针obj指向的对象是在堆上
2. block定义内部：在block结构体中（block在堆上）开一个同名的变量（堆上），指向obj指向的对象，被block持有，引用数+1
3. block定义后：obj没有变化。
*/
复制代码######（2）有_block修饰 基本数据类型
__block int b = 10;
NSLog(@"block定义前b地址=%p", &b);
void (^bBlock)() = ^(){
b = 20;
NSLog(@"block定义内b地址=%p", &b);
};
NSLog(@"block定义后b地址=%p", &b);
bBlock();
/*
结果：
block定义前b地址=0x7fff5c446c28
block定义后b地址=0x60400042b318
block定义内b地址=0x60400042b318
*/
复制代码指针类型：
__block NSString *obj = [[NSString alloc] initWithFormat:@"111"]; // 局部变量--指针变量，多提一下：“=”赋值右边的（alloc init）分配的地址是在堆上，左边obj指针地址是在栈上
NSLog(@"block定义前:[obj本身的地址=%p,obj指向的地址=%p]",&obj,obj);
void (^aBlock)() = ^(){
NSLog(@"block定义内:[obj本身的地址=%p,obj指向的地址=%p]",&obj,obj);
};
NSLog(@"block定义后:[obj本身的地址=%p,obj指向的地址=%p]",&obj,obj);
aBlock();
/*
结果：
block定义前:[obj本身的地址=0x7fff5d32fd38,obj指向的地址=0xa000000003131313]
block定义后:[obj本身的地址=0x600000052298,obj指向的地址=0xa000000003131313]
block定义内:[obj本身的地址=0x600000052298,obj指向的地址=0xa000000003131313]
*/
复制代码#####2、全局变量或者全局静态变量：因为都是在全局区，在程序结束前不会被销毁 block内部不需要处理全局变量或者全局静态变，直接使用
//所以block直接访问了对应的变量（没有对变量处理）
int global_var = 100;
static int static_global_var = 200;
void(^globalVarBlock)() = ^{
NSInteger var = global_var; // 可以使用
global_var = 1000; // 可以直接访问或者赋值
static_global_var = 10000; // 可以直接访问或者赋值
};
复制代码#####3、局部静态变量：将静态变量的指针传递给block，block通过静态局部变量的地址来进行访问 。
{
static NSInteger staticLocalVar = 10;
void(^staticLocalVarBlock)() = ^{
NSInteger bvar = staticLocalVar;//可以使用
staticLocalVar = 1000;//可以使用
};
}
复制代码####block的@property ARC会自动帮strong类型且捕获外部变量的block进行copy，所以在定义block类型的属性时也可以使用strong，不一定使用copy
// 假如有栈block赋给以下两个属性
// ARC，当栈block中会捕获外部变量时, 这个block会被copy进堆中
// 如果没有捕获外部变量，这个block会变为全局类型
// 不管怎么样，它都脱离了栈生命周期的约束
@property (nonatomic,strong) Block *strongBlock;
@property (nonatomic,copy) Block *copyBlock;
复制代码###四、block使用中出现retain cycle的问题、解决办法 最简单的循环问题代码
self.myBlock = ^{
NSLog(@"=====%@",self);//这种明显的循环引用，xcode会提示。
};
复制代码解决办法：(常用)
__weak __typeof(self)weakSelf = self;
self.myBlock = ^{
__strong __typeof(weakSelf)strongSelf = weakSelf;;//这个作用是防止block执行过程中self释放导致block执行了一半就GG。
NSLog(@"=====%@", strongSelf);
};
复制代码解决办法：(不常用) Block 多开一个参数，传入self，然后使用self的一些属性方法，这样子不会retain cycle
介绍做法： 为 block 多加一个参数，也就是 self 所属类型的参数，那么在 block 内部，该参数就会和 strongSelf 的效果一致。同时你也可以不写 weakSelf，直接使用使用该参数（作用等同于直接使用 strongSelf ）。这样就达到了：“多加一个参数，省掉两行代码”的效果。原理就是利用了“参数”的特性：参数是存放在栈中的(或寄存器中)，系统负责回收，开发者无需关心。因为解决问题的思路是：将 block 会捕获变量到堆上的问题，化解为了：变量会被分配到栈(或寄存器中)上，所以我把种做法起名叫 Heap-Stack Dance 。 引用来自--iOS程序猿 使用 Heap-Stack Dance 替代 Weak-Strong Dance，优雅避开循环引用。
#import "Foo.h"
typedef void (^Completion)(Foo *foo);
@interface Foo ()
@property (nonatomic, copy) Completion completion1;
@end
@implementation Foo
- (instancetype)init {
if (!(self = [super init])) {
return nil;
}
self.completion2 = ^(Foo *foo) {
//使用foo的各种属性、方法
};
self.completion2(self);
return self;
}
- (void)dealloc {
NSLog(@"dealloc");//这能执行
}
@end
复制代码####五、block的思考与实际使用的疑问，为什么有些系统SDK或者第三方库API中有block的使用中会引发循环引用，有些不会？
#####(1) GCD不会 （内部是copy这个block） dispatch_async(dispatch_get_global_queue(0, 0), ^{ // something NSLog(@"=====%@",self.view); });
#####(2) presentViewController不会 （这个block没有被任何对象持有，只是传进去执行） UIViewController *vc = [[UIViewController alloc] init]; [self presentViewController:vc animated:YES completion:^{ NSLog(@"=====%@",self.view); }];
#####(3) AFNetWork //self -> manager(AFHTTPSessionManager)->mutableTaskDelegatesKeyedByTaskIdentifier->delegate->block->self //AFNetwork 在请求结束后会自动释放掉 delegate,打破那个环,所以循环引用也就不存在了. manager = [[AFURLSessionManager alloc] initWithSessionConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]]; NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.hao123.com"]]; NSURLSessionDataTask *dataTask = [manager dataTaskWithRequest:request completionHandler:^(NSURLResponse *response, id responseObject, NSError *error) { NSLog(@"=====%@",self.view); }]; [dataTask resume];
#####(4) SDWebImage //slef -> view- -> imageView -> operationDictionary -> SDWebImageOperation -> OperationCompletedBlock -> imageViewCompletedBlock -> self //跟AFNetwork一样，等待operation请求完成自动remove，断开连接 UIImageView *imageView = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 100, 100)]; [self.view addSubview:imageView];//self.view会retain imageView。 [imageView sd_setImageWithURL:[NSURL URLWithString:@"http://img17.3lian.com/d/file/201702/18/3e8536054dd699a2134f86c200f7c079.jpg"] completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, NSURL *imageURL) { NSLog(@"=====%@",self.view); }];
AFNetwork、SDWebImage都是要等请求结束才能断开retain cycle，self得不到快速释放。假设请求时间100年，这个self就100年得不到释放。只是假设，哈哈
#####(5) 其他方式出现的retain cycle，NSNotification、NSTimer、自己写的delegate都需要好好注意一下！！！！ [[NSNotificationCenter defaultCenter] addObserverForName:@"SecondViewController" object:nil queue:NULL usingBlock:^(NSNotification *note) { }]; [NSTimer scheduledTimerWithTimeInterval:1 repeats:YES block:^(NSTimer * _Nonnull timer) {}];
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
