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 = ;
 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 = ;
   base += ;
   BlkSum sum = ^ long (int a, int b) {
     return base + a + b;
   };
   base++;
   printf("%ld",sum(,));  

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

__block int base = 50;

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

输出将是114，111；

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

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

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

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

举例如下：

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

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

static int base = ;
BlkSum sum = ^ long (int a, int b) {
  base++;
  return base + a + b;
};
base = ;
printf("%d\n", base);
printf("%ld\n",sum(,)); // 这里输出是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 * ;
 };  
 
 // 如果没有参数列表,在赋值时参数列表可以省略
 void(^aVoidBlock)() = ^{
     NSLog(@"I am a aVoidBlock");
 }; 

Block变量的调用

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

Block作为OC函数参数

 //1.定义一个形参为Block的oc函数
 - （void）userBlockForOC :(int (^)(int ,int ))aBlock{
     NSLog(@"result = %d", aBlock(,));
 }    
 
 //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 == ){
   //处理代码
  }
 }

再看一个例子

 //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();
     }
 }
 
 //.调用
 {
      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 = ;
  return (a + b) *n;
}

使用如下

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

三 提到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(), ^{ [self doSomething]; });

因为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, ), ^{  
 
 [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, ), ^{  
 
 __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修饰时，当再次访问时就会出现野指针访问。