iOS Block

最新推荐文章于 2024-05-27 12:46:15 发布

Benimaru_lx

最新推荐文章于 2024-05-27 12:46:15 发布

阅读量233

点赞数

分类专栏： iOS基础

本文链接：https://blog.csdn.net/u010967454/article/details/48047423

版权

iOS基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一. Block简述

Block作为C语言的扩展，但是由于Objective-C在iOS中不支持GC机制，使用Block必须自己管理内存，而内存管理正是使用Block坑最多的地方，错误的内存管理要么导致return cycle内存泄漏要么内存被提前释放导致crash。

Block的使用很像函数指针，不过与函数最大的不同是：

Block可以访问函数以外、词法作用域以内的外部变量的值。换句话说，Block不仅实现函数的功能，还能携带函数的执行环境。
Block类似ObjC的对象，可以使用自动释放池管理内存

Block其实包含两个部分内容

Block执行的代码，这是在编译的时候已经生成好的；
一个包含Block执行时需要的所有外部变量值的数据结构。 Block将使用到的、作用域附近到的变量的值建立一份快照拷贝到栈上

二. Block基本语法

返回值 (^名称)(参数列表)

三. Block的类型与内存管理

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

NSGlobalBlock：类似函数，位于text段；
NSStackBlock：位于栈内存，函数返回后Block将无效；
NSMallocBlock：位于堆内存。

1. 类型

(1). NSGlobalBlock如下，我们可以通过是否引用外部变量识别，未引用外部变量即为NSGlobalBlock，可以当做函数使用，为了方便使用也可以将其定义成宏函数

int main()
{
    ^{ 
	 printf("Hello, World!\n"); 
     } ();

    return 0;
}

(2). NSStackBlock如下，引入了外部变了

int main() 
{
    int a = 100;
    void (^block2)(void) = ^
    {
        printf("%d\n", a);
    };
    block2();

    return 0;
}
//在MRC环境下此处是NSStackBlock
// 在ARC环境下此处为NSMallocBlock
//为了管理内存ARC中默认会将block从栈复制到堆上，而在MRC中则需要手动copy

(3). NSMallocBlock只需要对NSStackBlock进行copy操作就可以获取，但是retain操作就不行,会在下面说明

2. 内存管理

不同于NSObjec的copy、retain、release操作：

Block_copy与copy等效，Block_release与release等效；
对Block不管是retain、copy、release都不会改变引用计数retainCount，retainCount始终是1；
NSGlobalBlock：retain、copy、release操作都无效；
NSStackBlock：retain、release操作无效，必须注意的是，NSStackBlock在函数返回后，Block内存将被回收。即使retain也没用。容易犯的错误是[[mutableAarry addObject:stackBlock]，（补：在arc中不用担心此问题，因为arc中会默认将实例化的block拷贝到堆上）在函数出栈后，从mutableAarry中取到的stackBlock已经被回收，变成了野指针。正确的做法是先将stackBlock copy到堆上，然后加入数组：[mutableAarry addObject:[[stackBlock copy] autorelease]]。支持copy，copy之后生成新的NSMallocBlock类型对象。
NSMallocBlock支持retain、release，虽然retainCount始终是1，但内存管理器中仍然会增加、减少计数。copy之后不会生成新的对象，只是增加了一次引用，类似retain, 由于没有生成新的对象， Block中引用的NSObject对象的retainCount不会发生变化；
尽量不要对Block使用retain操作

四. Block对外部变量的存取管理

1. 局部变量

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

{
    int base = 100;
    long (^sum)(int, int) = ^ long (int a, int b) 
    { 
        return base + a + b;
     };
    base = 0;
    printf("%ld\n",sum(1,2));
    // 这里输出是103，而不是3, 因为块内base为拷贝的常量 100
}

2. static修饰符的全局变量

因为全局变量或静态变量在内存中的地址是固定的，Block在读取该变量值的时候是直接从其所在内存读出，获取到的是最新值，而不是在定义时copy的常量.

{
    static int base = 100;
    long (^sum)(int, int) = ^ long (int a, int b) 
    {
        base++;
        return base + a + b;
     };
    base = 0;
    printf("%ld\n",sum(1,2));
    // 这里输出是4，而不是103, 因为base被设置为了0
    printf("%d\n", base);
    // 这里输出1， 因为sum中将base++了
}

3. __block修饰的变量

Block变量，被__block修饰的变量称作Block变量。基本类型的Block变量等效于全局变量、或静态变量。

注：BLOCK被另一个BLOCK使用时，另一个BLOCK被COPY到堆上时，被使用的BLOCK也会被COPY。但作为参数的BLOCK是不会发生COPY的

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

4. NSObject对象

block对于objc对象的内存管理较为复杂，这里要分static、global、local、block变量分析，而且还要分MRC和ARC

MRC代码：

@interface TestBlockForMRC : NSObject 
{
    NSObject *_instanceObj;
}
@end
 
@implementation TestBlockForMRC
 
NSObject* __globalObj = nil;
typedef void (^MyBlock)(void);
 
- (id) init 
{
    if (self = [super init]) 
    {
        _instanceObj = [[NSObject alloc] init];
    }
    return self;
}
 
- (void) testBlock 
{
    static NSObject *__staticObj = nil;
    __globalObj = [[NSObject alloc] init];
    __staticObj = [[NSObject alloc] init];
    NSObject *localObj = [[NSObject alloc] init];
    __block NSObject *blockObj = [[NSObject alloc] init];
 
    MyBlock aBlock = ^
    {
        NSLog(@"%@", __globalObj);
        NSLog(@"%@", __staticObj);
        NSLog(@"%@", _instanceObj);
        NSLog(@"%@", localObj);
        NSLog(@"%@", blockObj);
    };
    aBlock = [[aBlock copy] autorelease];
    aBlock();
 
    NSLog(@"%d", [__globalObj retainCount]);      //1
    NSLog(@"%d", [__staticObj retainCount]);      //1
    NSLog(@"%d", [_instanceObj retainCount]);     //1
    NSLog(@"%d", [localObj retainCount]);         //2
    NSLog(@"%d", [blockObj retainCount]);         //1
}
@end

__globalObj和__staticObj在内存中的位置是确定的，所以Block copy时不会retain对象。
_instanceObj在Block copy时也没有直接retain _instanceObj对象本身，但会retain self。所以在Block中可以直接读写 _instanceObj变量。
localObj在Block copy时，系统自动retain对象，增加其引用计数。
blockObj在Block copy时也不会retain。

ARC代码：

由于ARC中没有retain，retainCount的概念。只有强引用和弱引用的概念。当一个变量没有__strong的指针指向它时，就会被系统释放。因此我们可以通过下面的代码来测试

@interface ARCViewController ()
{
    NSString           *_instanceString;
}

@end

@implementation ARCViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self testBlockARC];
}

NSString *__globalString = nil;

- (void)testBlockARC
{
    __globalString = [NSString stringWithFormat:@"%@", @"testARCGlobal"];
    printf("global address: %p\n", &__globalString);                //0xd534
    
    static NSString *__staticString = nil;
    __staticString = [NSString stringWithFormat:@"%@", @"testARCStatic"];
    printf("static address: %p\n", &__staticString);                //0xd53c
    
    NSString *__localString = [NSString stringWithFormat:@"%@", @"testARCLocal"];
    printf("local address: %p\n", &__localString);                  //0xbfffc830
    printf("local str address: %p\n", __localString);               //0x8f07e80
    
    __block NSString *__blockString = [NSString stringWithFormat:@"%@", @"testARCBlock"];
    printf("block address: %p\n", &__blockString);                  //0xbfffc830
    printf("block str address: %p\n", __blockString);               //0x8f95d40
    
    __weak NSString *__weakString = [NSString stringWithFormat:@"%@", @"testARCWeak"];
    printf("weak address: %p\n", &__weakString);                    //0xbfffc834
    printf("weak str address: %p\n", __weakString);                 //0x8c5b030
    
    void (^TestBlock)(void) = ^
    {
        NSLog(@"globalString is :%@", __globalString);                    //nil
        printf("global address: %p\n", &__globalString);                  //0xd534
        
        NSLog(@"staticString is :%@", __staticString);                    //nil
        printf("static address: %p\n", &__staticString);                  //0xd53c
        
        NSLog(@"localString is :%@", __localString);                      //"testARCLocal"
        printf("local address: %p\n", &__localString);                    //0x8e87d24
        printf("local str address: %p\n", __localString);                 //0x8f07e80
        
        NSLog(@"blockString is :%@", __blockString);                      //nil
        printf("block address: %p\n", &__blockString);                    //0x8e16418
        printf("block str address: %p\n", __blockString);                 //0x0
        
        NSLog(@"weakString is :%@", __weakString);                        //testARCWeak
        printf("weak address: %p\n", &__weakString);                      //0x8f3e6d4
        printf("weak str address: %p\n", __weakString);                   //0x8c5b030
    };
    
    __globalString = nil;
    __staticString = nil;
    __localString = nil;
    __blockString = nil;
    __weakString = nil;
    
    TestBlock();
}

由以上几个测试我们可以得出：

只有在使用local变量时，block会复制指针，且强引用指针指向的对象一次。其它如全局变量、static变量、block变量等，block不会拷贝指针,只会强引用指针指向的对象一次。
标记了为__weak或__unsafe_unretained的local变量。block也会复制指针，且强引用指针指向的对象一次, 这是因为在block中需要对__weak变量进行strong,保证代码在执行到block中，__weak所指对象不会被释放，当block执行完后，会自动释放该__weak所指对象

5.循环引用

循环引用指两个对象相互强引用了对方，即retain了对方，从而导致谁也释放不了谁的内存泄露问题。如声明一个delegate时一般用assign而不能用retain或strong，因为你一旦那么做了，很大可能引起循环引用。在以往的项目中，我几次用动态内存检查发现了循环引用导致的内存泄露。

这里讲的是block的循环引用问题，因为block在拷贝到堆上的时候，会retain其引用的外部变量，那么如果block中如果引用了他的宿主对象，那很有可能引起循环引用

实例如下

- (id)init
{
    self = [super init];
    if (self) {
 
#if TestCycleRetainCase1
 
        //会循环引用
        self.myblock = ^{
 
            [self doSomething];
        };

#elif TestCycleRetainCase2
 
        //会循环引用
        __block TestCycleRetain *weakSelf = self;
        self.myblock = ^{
 
            [weakSelf doSomething];
        };
 
#elif TestCycleRetainCase3
 
        //不会循环引用
        __weak TestCycleRetain *weakSelf = self;
        self.myblock = ^{
 
            [weakSelf doSomething];
        };
 
#elif TestCycleRetainCase4
 
        //不会循环引用
        __unsafe_unretained TestCycleRetain *weakSelf = self;
        self.myblock = ^{
 
            [weakSelf doSomething];
        };
 
#endif
 
        NSLog(@"myblock is %@", self.myblock);
 
    }
    return self;
}

经过上面的测试发现，在加了__weak和__unsafe_unretained的变量引入后，TestCycleRetain方法可以正常执行dealloc方法，而不转换和用__block转换的变量都会引起循环引用。因此防止循环引用的方法如下：__unsafe_unretained TestCycleRetain *weakSelf = self;