Block讲解一

Block专辑:

本篇博客

MRC-block与ARC-block

Block详解一(底层分析)

 

一.Block的本质

 （1）block其实是一个对象， 在存放block对象的内存区域中，也包含我们经常说的isa指针，和一些能让block正常运转的各种信息。关于isa指针，在oc中每个实例对象都会有一个isa指针，指向对象的类，其实在类里面也会有isa指针，这个指针指向该类的元类。

（2）内存分配

栈：是由编译器自动分配释放，存放函数的参数值，局部变量的值以及函数返回地址。所以我们每次调用函数,都会执行压栈操作。特点是存取效率高,存取结构连续,但是空间很小,有系统自行分配以及管理栈的地址空间。

堆：由程序员分配释放，如果程序员不释放，程序结束的时候系统会收回,我们平时涉及到内存管理基本上出自于这个区域。由malloc,alloc,copy(深拷贝),new等方法触发的效果就是在堆区进行内存分配。

静态区: 该区域其实可以细分为数据区以及BSS(静态内存分配)区。数据区存放于已经初始化好的静态变量以及全局变量,而BSS区则存放还没有初始化好的静态变量以及全局变量,由系统负责释放以及分配。

常量区:存放常量,由系统释放以及分配。

代码区(文本区): 存放函数体代码。

 

我们定义block的时候，其所占的内存区域是分配在栈上。如果在编写程序的时候，稍加不注意，肯能会出现问题。

void (^block)();
if (isSure) {
  block = ^{
    NSLog(@"blockA");
  };
}else
{
  block = ^{
    NSLog(@"blockB");
  };
}
block();

 因为block的内存分配在栈上的，栈上的内存是系统管理的，如果编译器没有覆写待执行的block，程序正常，如果覆写了，程序就会崩溃。

如何解决问题：也就是我们经常看到的，修饰block的时候，用copy。让block从栈中复制到堆上，copy之后该block就成了带引用计数的对象。

void (^block)();
if (isSure) {
  block = [^{
    NSLog(@"blockA");
  } copy ];
}else
{
  block = [^{
    NSLog(@"blockB");
  } copy];
}
block();

 这样写，代码就会安全。如果手动管理内存，用完之后可以手动将其释放。

block除了存储栈和堆上，还有一个全局的block（不会捕获变量，存放在全局的内存里面），block的内存存储区域。

block 在内存中的位置

根据Block在内存中的位置分为三种类型NSGlobalBlock，NSStackBlock, NSMallocBlock。

NSGlobalBlock：类似函数，位于text段；当我们声明一个block时,如果没有这个block没有捕获外部的变量,那么这个block就位于全局区,此时对NSGlobalBlock的retain、copy、release操作都无效,ARC与MRC均是如此。

NSStackBlock：位于栈内存，函数返回后Block将无效；平时编程的时候很少遇到位于栈区的block，为什么呢？因为在ARC环境下，当我们声明并且定义了一个block，并且没有为Block添加额外的修饰符（默认是__strong修饰符），如果该Block捕获了外部的变量，实质上是有一个从__NSStackBlock__转变到__NSMallocBlock__的过程，只不过是系统帮我们完成了copy操作，将栈区的block迁移到堆区，延长了Block的生命周期。对于栈区block而言，栈block在当函数退出的时候，该空间就会被回收。

那什么时候在ARC的环境下出现__NSStackBlock__呢？如果我们在声明一个block的时候，使用了__weak或者__unsafe__unretained的修饰符，那么系统就不会为我们做copy的操作，不会将其迁移到堆区。

NSMallocBlock：位于堆内存。们需要手动调用copy方法才可以将block迁移到堆区，而在ARC环境下，__strong修饰的（默认）block只要捕获了外部变量就会位于堆区，NSMallocBlock支持retain、release，会对其引用计数＋1或 -1。

 

示例1:  
  
BlkSum blk1 = ^ long (int a, int b) {  
  return a + b;  
};  
NSLog(@"blk1 = %@", blk1);// 打印结果：blk1 = <__NSGlobalBlock__: 0x47d0>  
  
  
  
示例2:  
  
int base = 100;  
BlkSum blk2 = ^ long (int a, int b) {  
  return base + a + b;  
};  
NSLog(@"blk2 = %@", blk2); // 打印结果：blk2 = <__NSStackBlock__: 0xbfffddf8>  
  
  
示例3:  
  
BlkSum blk3 = [[blk2 copy] autorelease];  
NSLog(@"blk3 = %@", blk3); // 打印结果：blk3 = <__NSMallocBlock__: 0x902fda0> 

 blk1和blk2的区别在于：

blk1没有使用block以外的任何外部变量，Block不需要建立局部变量值的快照，这使得block1与一般函数没有任何区别；而blk2使用了局部变量base。

注意：在定义blk3时，局部变量base被copy到栈上，作为常量供block使用，列如下面的结果为103，而不是104

int base = 50;  
  base += 50;  
  BlkSum sum = ^ long (int a, int b) {  
    return base + a + b;  
  };  
  base++;  
  printf("%ld",sum(1,2));  

在Block内变量base是只读的，如果想在block内改变base的值，在定义base时要用__block修饰

__block int base = 50;

__block int base = 50;  
base += 50;  
BlkSum sum = ^ long (int a, int b) {  
  base += 10;  
  return base + a + b;  
};  
base++;  
printf("%ld\n",sum(1,2));  
printf("%d\n",base); 

输出将是114，111；

注意：Block中使用__block修饰的变量时，将取变量此刻运行的值，而不是定义的快照。

如果将block捕获的外部变量使用static修饰或者将外部变量声明为全局变量，那么block是可以直接修改该外部变量的，因为全局变量或静态变量在内存中的地址是固定的（存放于上文中的静态区），Block在读取该变量值的时候是直接从其所在内存读出，获取到的是最新值，而不是在定义时copy的常量。

拓展：（3）中也有讲到：

局部自动变量：在block中只读。block定义时copy变量的值，在Block中作为常量使用，所以即使变量的值在block外改变，也不影响在block中的值。

举例如下：

int base = 100;  
BlkSum sum = ^ long (int a, int b) {  
  // base++; 编译错误，只读  
  return base + a + b;  
};  
base = 0;  
printf("%ld\n",sum(1,2)); // 这里输出是103，而不是3  

static 修饰变量，效果与__block一样

static int base = 100;  
BlkSum sum = ^ long (int a, int b) {  
  base++;  
  return base + a + b;  
};  
base = 0;  
printf("%d\n", base);  
printf("%ld\n",sum(1,2)); // 这里输出是3，而不是103 
printf("%d\n", base); 

输出结果时：0；4；1

表明Block外部对base的更新会影响Block中的base的取值，同样Block对base的更新也会影响Block外部的base值。

得出一个结论：Block变量，被__block修饰的变量称作Block变量。基本类型的Block变量等效于全局变量、或静态变量

（3）捕获变量

下面有一个问题，说明：

int  c = 6;
    
    int (^addBlock) (int a) = ^(int a){
      
        return a + c;
    };
    
    int addValue = addBlock(2);// addValue = 8;
}

 在声明的block范围内，所以变量都可以为其捕获，也就是说，在那个范围内所有的变量，在块里面都可以使用。如果要想在外面改变变量值的话，就必须使用__block修饰。

__block int add = 5;

 分析：

栈里面的block：
如果该block储存在栈里面，那么该block只会在声明的作用范围内有效，作用域结束的时候，栈上的__block变量和block也会被废弃。也就是说block和捕获的变量被系统一块释放了。在栈里面的__block变量只是被block使用而已，而没有被block所持有。

堆里面的block：
当栈里面的block被Copy到堆里面的时候，__block变量也会被copy到堆里面并且会被block所持有，只有不被block持有的时候才会被释放。

全局里面block：只有不被block持有的时候才会被释放。

（4）block封装了一段代码，可以在任何时候执行；block可以作为函数参数或者函数的返回值，而其本身又可以带输入参数或者返回值；它和传统函数指针类似，但是有区别：block是inline（内联函数）的，并且默认情况下，blokc对局部变量都是只读的；block代码：是一个函数对象，是在程序运行过程中产生的，普通函数：是一段固定代码，产生于编译期。

 

二.Block的定义与使用

（1）完整定义如下：

 

returnType (^blockName)(parameterTypes) = ^returnType(parameters) {...};

举例说一下：

void (^myBlock)(void);//无返回值，无参数
void(^myBlock)(int,int);//无返回值，有参数
NSString *(^myBlock)(NSString *name ,int age);//有返回值和参数，并且在参数类型后面加入了参数名(仅为可读性)

 （2）block的变量的声明

block变量的声明格式如下：返回值类型（^block名字）（参数列表）；----形参变量名称可以省略，只保留变量类型即可

// 声明一个无返回值,参数为两个字符串对象,叫做aBlock的Block  
void(^aBlock)(NSString *x,NSString * y);
  
// 形参变量名称可以省略,只留有变量类型即可  
void(^aBlock)(NSString *, NSString *);

 (3)block的定义和举例

/*定义属性，block属性可以用Strong修饰，也可以用copy修饰**/
@property （nonatomic，strong）void（^myBlock）();//无参无返回值
@property （nonatomic ,strong）void（^myBlock）(NSString *);//带参数无返回值
 @property (nonatomic, strong) NSString *(^myBlock2)(NSString *);  //带参数与返回值  

//定义变量
void （^myBlock）() = nil;//无参无返回值
void （^myBlcok）(NSString *) = nil;//带参数无返回值
NSString *(^myBlock)(NSString *) = nil;//带参数无返回值

block被当做方法的参数
格式：（block类型）参数名称
- （void）test:(void(^)())testBlock;//无参无返回值
- （void）test:(void(^)(NSString *))testBlock; //带参数无返回值 
- （void）test:(NSString *(^)(NSString *))testBlock;//带参数与返回值  


使用typedef定义block
typedef  void (^myBlock)();//以后就可以使用myBlock定义无参无返回值的
typedef void (^myBlock)(NSString *) //使用myBlock1定义参数类型为NSString的block  
typedef (NSString *)（^myBlock）(NSString *);//使用myBlock2定义参数类型为NSString，返回值也为NSString的block  
//定义属性
@property （nonatomic，strong）myBlock  testBlock；
//定义变量
myBlock testBlock = nil;
//当做参数
- （void）test：（myBlock）testBlock；

 （3）block的赋值

格式：block =  ^返回值类型（参数列表）{}

注4: 通常情况下，可以省略返回值类型，因为编译器可以从存储代码块的变量中确定返回值的类型。

没有参数没有返回值  
myBlock testBlock = ^void(){  
     NSLog(@"test");  
 };  
  
没有返回值，void可以省略  
myBlock testBlock1 = ^(){  
     NSLog(@"test1");  
 }；  
  
没有参数，小括号也可以省略  
myBlock testBlock2 = ^{  
     NSLog(@"test2");  
 }；  
  
有参数没有返回值  
myBlock1 testBlock = ^void(NSString *str) {  
      NSLog(str);  
}  
  
省略void  
myBlock1 testBlock = ^(NSString *str) {  
      NSLog(str);  
}  
  
有参数有返回值  
myBlock2 testBlock = ^NSString *(NSString *str) {  
     NSLog(str)  
     return @"hi";  
}  
  
有返回值时也可以省略返回值类型  
 myBlock2 testBlock2 = ^(NSString *str) {  
     NSLog(str)  
     return @"hi";  
}  

声明Block变量的同时进行赋值

int(^myBlock)(int) = ^(int num){  
    return num * 7;  
};  
  
// 如果没有参数列表,在赋值时参数列表可以省略  
void(^aVoidBlock)() = ^{  
    NSLog(@"I am a aVoidBlock");  
}; 

Block变量的调用

// 调用后控制台输出"Li Lei love Han Meimei"  
aBlock(@"Li Lei",@"Han Meimei");  
  
// 调用后控制台输出"result = 63"  
NSLog(@"result = %d", myBlock(9));  
  
// 调用后控制台输出"I am a aVoidBlock"  
aVoidBlock(); 

Block作为OC函数参数

//1.定义一个形参为Block的oc函数
- （void）userBlockForOC :(int (^)(int ,int ))aBlock{
    NSLog(@"result = %d", aBlock(300,200));  
}    

//2.声明并赋值定义一个Block变量
int (^addBlock)(int ,int )= ^(int x,int y){
  return x+ y;  
}

//3.以Block作为函数参数，把参数像对象一样传递
[self userBlockForOC:addBlock];

//4. 将第2点和第3点合并一起,以内联定义的Block作为函数参数  
[self useBlockForOC:^(int x, int y){  
    return x+y;  
}]; 

 （4）block在定义时并不会执行内部的代码，只有在调用时候才会执行。下面通过两个例子：

//在AViewController.h定义
@property （nonatomic，copy）void （^successBlock）(NSInteger count);

//在在MyViewController.m赋值
if(self.successBlock && ){
  self.successBlock([self.cards count]);  
}

//在BViewController.m中调用：  
AViewController *aa = [[AViewController alloc]init];
//回调要如何处理
aa.successBlock  = ^(NSInteger count){
 if(count == 0){
  //处理代码  
 }
}

再看一个例子

//1.在IOABgPopView.h中

#import <UIKit/UIKit.h>

typedef void (^popCallback)();

@interface IOABgPopView : UIView

+ (IOABgPopView *)show;

@property(nonatomic,copy)popCallback clickCallBack;

@end


//2.在IOABgPopView.m中

- (void)closeTap{
    if (self.clickCallBack) {
        self.clickCallBack();
    }
}

//3.调用
{
     IOABgPopView *show = [IOABgPopView show];
    self.show = show;
    WS(weakSelf);
    self.show.clickCallBack = ^{
        [weakSelf closeTap];
   };
}
   

最后一个例子：用typedef为block进行重命名

我们可以使用typedef为block进行一次重命名，方法跟为函数指针命名是一样的：
 typedef int （^sum）(int ,int);

这样我们就利用typedef定义了一个block，这个block的名字就是宿命，需要传两个参数，应该这样使用

Sum mysum = ^(int a,int b){
  n = 2;
  return (a + b) *n;
}

使用如下

typedef int (^Sum) (int, int);  

int main(int argc,const charchar *argv){
 __block int n = 1;
 @autoreleasepool {
   Sum mysum = ^(int a,int b ){
      n = 2;
      return (a + b)*n;
    };
    NSLog(@"(3 + 5) * %i = %d", n, mysum(3, 5)); 
 }
 return 0;
}    

 三 提到block，无论是面试还是实际开发中，都会提到一个词语“循环引用”，首先看下面一个例子：

（1）

@implementation TsetBlock  
-(id)init{  
   if (self = [superinit]) {  
       self.testStr =@"中国";  
        self.block = ^(NSString *name, NSString *str){  
           NSLog(@"arr:%@",self.testStr); // 编译警告：Capturing 'self' strongly in this block is likely to lead to a retain cycle  
       };  
   }  
   returnself;  
}  
@end  

看到这个例子，很多人都表述为“block里面使用self导致循环引用”其实这种说法是不严谨的，不一定出现“self”字眼才会引起循环引用，再比如：

@implementation TsetBlock  
  
-(id)init{  
  
   if (self = [superinit]) {  
       self.testStr =@"中国";  
        self.block = ^(NSString *name,NSString *str){  
           NSLog(@"arr:%@", _testStr); // 同样出现： Capturing 'self' strongly in this block is likely to lead to a retain cycle  
       };  
   }  
   returnself;  
}  
@end 

可以发现block代码中没有显示self，也会出现循环引用！所以只要你在block里面用到了self所拥有的的东西！

解决方案：

在ARC下不用__block，而是用__weak为了避免出现循环引用。

1.ARC：用__week

__weaktypeof (self)  weakSelf = self; 或者

__weak someClass *weakSelf = self;

2.MRC：用__block ，__block修饰的变量在Block copy时是不会retain的，所以，也可以做到破解循环引用。
__block someClass *blockSelf = self;

Block的copy、retain、release操作

对Block不管是retain、copy、release都不会改变引用计数retainCount，retainCount始终是1；

NSGlobalBlock：retain、copy、release操作都无效；
NSStackBlock：retain、release操作无效，必须注意的是，NSStackBlock在函数返回后，Block内存将被回收。即使retain也没用。容易犯的错误是[[mutableAarry addObject:stackBlock]，在函数出栈后，从mutableAarry中取到的stackBlock已经被回收，变成了野指针。正确的做法是先将stackBlock copy到堆上，然后加入数组：[mutableAarry addObject:[[stackBlock copy] autorelease]]。支持copy，copy之后生成新的NSMallocBlock类型对象。
NSMallocBlock支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数。copy之后不会生成新的对象，只是增加了一次引用，类似retain；
尽量不要对Block使用retain操作。

（2）block 循环引用？？？

因为两个对象相互持有，这样就会造成循环引用。如下图所示：

两个对象相互持有，对象A持有对象B，对象B持有对象A，相互持有，最终导致两个对象都不能释放。

1.block在主函数内体用到了self/self.变量/[self 方法]意味着block对self进行持有操作；

2.self声明了属性变量block，block用copy修饰，意味着：self对block进行持有操作，会造成循环引用。

typedef void(^block)();  
  
@property (copy, nonatomic) block myBlock;  // 2  
@property (copy, nonatomic) NSString *blockString;  
  
  
- (void)testBlock {  
    self.myBlock = ^() {  
        //其实注释中的代码，同样会造成循环引用  
        NSString *localString = self.blockString; // 1  
          //NSString *localString = _blockString;  
          //[self doSomething];  
    };  
}  

解决方案：

解决方法：  
  
__weak typeof(self) weakSelf = self;  
self.myBlock = ^() {  
    NSString *localString = weakSelf.blockString;  
}; 

什么时候在block中又不需要weakSelf？？？不会造成循环引用？？？

1.大部分的GCD方法

 dispatch_async(dispatch_get_main_queue(), ^{ 2 [self doSomething]; 3 }); 

因为self并没有对GCD的block进行持有，没有造成循环引用，

2.大部分的动画效果

当动画结束时，UIView 会结束持有这个 block，block 对象就会释放掉，从而 block 会释放掉对于 self 的持有。整个内存引用关系被解除

3.block并不是对象的属性/变量，而是方法的参数/临时变量

-  (void) doSomething {  
    [self testWithBlock:^{  
        [self test];  
    }];  
}  
  
-  (void) testWithBlock:(void(^)())block {  
    block();  
}  
  
-  (void) test {  
    NSLog(@"test");  
}

这里因为block只是一个临时变量，self并没有对其持有，所以没有造成循环引用

 说到了weakSelf，还有一个strongSelf？？？

看下面一种情况：

__weak __typeof__(self) weakSelf = self;    
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
  
[weakSelf doSomething];  
[weakSelf doOtherThing];  
  
});  

在 doSomething 中，weakSelf 不会变成 nil，不过在 doSomething 执行完成，调用第二个方法 doOtherThing 的时候，weakSelf 有可能被释放，于是，strongSelf 就派上用场了：

__weak __typeof__(self) weakSelf = self;  
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
  
__strong __typeof(self) strongSelf = weakSelf;  
[strongSelf doSomething];  
[strongSelf doOtherThing];  
  
});  

__strong确保在block内，strongSelf不会被释放

总结如下：

1.在Block内如果访问self的方法、变量、建议使用weakSef

2.在Block中需要多次访问self，则需要使用StrongSelf

 

 

最后说一下：

iOS为什么要用copy修饰：

默认情况下，block是存在栈中的，可能被随时回收，通过copy操作将其在堆中保留一份，相当于一直被强引用着，因此如果block用到self，需要将其弱化， 通过__weak或者__unsafe_unretained.  

如果属性的block使用assign修饰时，当再次访问时就会出现野指针访问。