美文网首页
Objective-C高级编程（中）：Block

Objective-C高级编程（中）：Block

作者: 六号先生117 | 来源:发表于2018-10-17 09:41 被阅读345次

    《Objective-C高级编程：iOS与OS X多线程和内存管理》是iOS开发中一本经典书籍，书中有关ARC、Block、GCD的梳理是iOS开发进阶路上必不可少的知识储备。笔者读完此书后为了加强理解，特以笔记记之。本文为中篇，主要谈论Objective-C中的Block。

    Block

    鉴于本书翻译自日文原版且翻译偏向书面，笔者希望采用通俗的语言记录，文章结构略有调整。

    本文首发于Rachal's blog。

    Block概要

    定义：Block是带有自动变量（局部变量）的匿名函数。

    匿名函数就是不带名称的函数。

    C语言的函数中可能使用的变量：

    • 自动变量（局部变量）
    • 函数的参数
    • 静态变量（静态局部变量）
    • 静态全局变量
    • 全局变量

    前两种在超出作用域会销毁，后三种可以在函数的多次调用之间传递。

    在计算机科学中，“带有自动变量值的匿名函数”这一概念称为闭包，Block就是Objective-C对闭包的实现。

    Block模式

    Block语法

    Block的完整语法：^ 返回值类型 参数列表 表达式

    ^ int (int count) {return count + 1;}

    完整形式的Block语法与一般C语言函数定义相比，仅有两点不同：

    • 没有函数名
    • 带有^

    其中返回值类型和参数列表可省略，省略后为：^ 表达式

    ^ {printf("Blocks\n");}

    Block变量类型

    在Block语法中下，可将Block语法赋值给声明为Block类型的变量。

    int (^blk)(int);// 声明Block类型

int (^blk1)(int) = ^(int count) {return count + 1};// 变量blk1
int (^blk2)(int);// 变量blk2

blk2 = blk1;// Block类型变量赋值

    通过typedef可声明Block类型变量，函数定义就变得更容易理解。

    typedef int (^blk)(int);

blk blk1 = ^(int count) {return count + 1;};
blk blk2 = blk1; // blk类型变量赋值

    截获自动变量

    • Block可以截获自动变量的值。
    NSInteger aa = 10;

void (^blk)(void) = ^{
    NSLog(@"%ld",aa);
};

aa = 2;

blk();

// 输出结果为10
    • Block中使用时向截获的自动变量进行赋值会出错。
    id array = [[NSMutableArray alloc] init];

void (^blk) (void) = ^{

    id obj = [[NSObject alloc] init];

    /* 使用array变量调方法，没问题 */
    [array addObject:obj];
};

blk();

    id array = [[NSMutableArray alloc] init];

void (^blk) (void) = ^{

    /* 想array变量赋值，出错 */
    array = [[NSMutableArray alloc] init];
};

blk();

    __block说明符

    若想在Block语法的表达式中将值赋给在Block语法外声音的自动变量，需要在该自动变量上附加__block说明符。

    __block int val = 0;

void (^blk)(void) = ^{val = 1;};

blk();

printf("val = %d\n",val);// 输出结果为val = 1;

    __block id array = [[NSMutableArray alloc] init];

void (^blk) (void) = ^{

    /* 向array变量赋值，不会出错 */
    array = [[NSMutableArray alloc] init];
};

blk();

    Block实现

    Block的实质

    将Objective-C代码转化成可读源码（C++）的方法：

    // 终端cd 源代码文件夹
clang -rewrite-objc 源代码文件名

    书中将一段Block代码转化为可读的C++源码，简化源码，关注其中的结构体：

    struct __main_block_imp_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
}

struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
}

    Block的结构体中含有isa指针，足以证明Block即为Objective-C的对象。

    isa = &_NSConcreteStackBlock;

    isa被初始化，说明在将Block作为Objective-C的对象处理时，关于该类的信息放置于_NSCocreteStackBlock中。

    三种Block

    前面提到了_NSConcreteStackBlock类型的Block，与之对应的还有_NSConcreteGlobalBlock、_NSConcreteMallocBlock。

    名称 Block的类 对象存储域 复制效果
    栈Block _NSConcreteStackBlock 栈 从栈复制到堆
    堆Block _NSConcreteMallocBlock 堆 引用计数增加
    全局Block _NSConcreteGlobalBlock 程序的数据区（.data区） 什么也不做

    全局Block产生途径：

    • 记述全局变量的地方有Block语法时
    • Block语法的表达式中不使用应截获的自动变量时

    除此之外的Block语法生成的Block为栈Block，将栈上的Block复制到堆上，Block就会变成堆Block。

    Blobk如何截获自动变量值

    通过clang源码转换得知：

    Block语法表达式中使用的自动变量被作为成员变量追加到Block的结构体中。Block语法表达式中没有使用的自动变量不会被追加。Block的自动变量截获只针对Block中使用的自动变量。

    所谓“截获自动变量值”意味着在执行Block语法时，Block语法表达式所使用的的自动变量值被保存到Block的结构体实例（即Block自身）中。

    __block变量

    __block说明符能用来指定Block中想变更值的自动变量。

    准确的表述方式为“__block存储域类说明符”，C语言中有以下存储域类说明符：

    • typedef
    • extern
    • static
    • auto
    • register

    它们用于指定将变量值设置在哪个存储域中。例如：auto表示作为自动变量存储在栈中，static表示作为静态变量存储在数据区。

    自动变量加上__block，源代码会急剧增加，变量的转换如下：

    __block int val = 10;

    __Block_byref_val_0 val = {
    0,
    &val,
    0,
    sizeof(__Block_byref_val_0),
    10
};

    自动变量转换后竟然变成了结构体实例，即栈上生成的__Block_byref_val_0结构体实例。

    结构体声明如下：

    struct __Block_byref_val_0 {
    void *__isa;
    __Block_byref_val_0 *__forwarding;
    int __flags;
    int __size;
    int val;
};

    __Block_byref_val_0结构体实例的成员变量__forwarding持有指向该实例自身的指针，也就是原自动变量。

    访问__block变量

    另外，__block变量的__Block_byref_val_0结构体并不在Block的结构体中，这样做是为了在多个Block中使用__block变量。

    Block从栈复制到堆时，__block变量也会一并从栈复制到堆并被该Block所持有。在多个Block中使用__block变量时，被复制的Block持有__block变量，并增加__block变量的引用计数。如果配置在堆上的Block被废弃，那么它所使用的__block变量也就被释放。

    栈上的__block变量的结构体实例在复制到堆上时，会将成员变量__forwarding的值替换为复制目标堆上的__block变量的结构体的地址。

    复制__block变量

    通过该功能，无论是在Block语法中、Block语法外使用__block变量，还是__block变量配置在栈上或堆上，都可以顺利访问同一个__block变量。

    Block截获的对象和__block变量

    - (void)blockTest {

    blk_t blk;

    {
        id array = [[NSMutableArray alloc] init];

        blk = ^(id obj){

        [array addObject:obj];

            NSLog(@"array count is %ld", [array count]);
        };
    }

    blk([[NSObject alloc] init]);
    blk([[NSObject alloc] init]);
    blk([[NSObject alloc] init]);
}

    以上blockTest方法在ARC无效和有效情况下执行结果：

    • ARC无效时，程序会强制结束。因为对象array超出作用域后不存在。
    • ARC有效时，输出如下：
    array count is 1
array count is 2
array count is 3

    ARC有效时，大部分情况下编译器会适当的进行判断，自动生成将Block从栈上复制到堆上的代码。被栈上Block截获的对象可以超出作用域而存在。

    通过编译器转换后的源码查看Block结构体，发现Block结构体中有__strong修饰的成员变量array。

    struct __main_block_impl_0 {
    struct __blobk_impl impl;
    struct __main_block_desc_0* Desc;
    id __strong array;
}

    C语言结构体中不能含有__strong修饰的变量，因为编译器不能很好地对其内存管理。但是Objective-C运行时库能够准确把握从栈复制到堆上的Block被废弃的时机，恰当地对变量进行初始化和废弃。

    在此对比截获对象和使用__block变量时持有（copy）和废弃（dispose）函数源码：

    • 截获对象：
    static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src) {
    _Block_object_assign(&dst->array, src->array, BLOCK_FIELD_IS_OBJECT);
}

    static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
    _Block_object_dispose(src->array, BLOCK_FIELD_IS_OBJECT);
}
    • 使用__block变量：
    static void __main_block_copy_0(struct __main_block_impl_0 *dst, struct __main_block_impl_0 *src) {
    _Block_object_assign(&dst->val, src->val, BLOCK_FIELD_IS_BYREF);
}

    static void __main_block_dispose_0(struct __main_block_impl_0 *src) {
    _Block_object_dispose(src->val, BLOCK_FIELD_IS_BYREF);
}

    通过对比发现：

    • 截获对象和__block变量使用_Block_object_assign函数
    • 废弃对象和__block变量使用_Block_object_dispose函数
    • 通过Block_FIELD_IS_OBJECT和BLOCK_FIELD_IS_BYREF参数区分copy和dispose函数的对象类型是对象还是__block变量。

    由此可知：Block中使用的赋值给__strong修饰（ARC下常省略）的自动变量的对象和复制到堆上的__block变量，由于被堆上的Block所持有，因而可超出其变量作用域而存在。

    栈上的Block复制到堆上的时机：

    • 调用Block的copy方法时
    • Block作为函数返回值返回时
    • 将Block赋值给__strong修饰的id类型或Block类型变量时
    • 在方法名中含有usingBlock的Cocoa框架方法或GCD的API中传递Block时

    栈上的Block为何需要复制到堆上

    将栈上的Block复制到堆上，这样即使Block记述的变量作用域结束，堆上的Block还可以继续存在。

    - (void)blockTest {
    id obj = [self getBlockArray];

    typedef void (^blk_t)(void);

    blk_t blk = (blk_t)[obj objectAtIndex:0];

    blk();
}

- (id)getBlockArray {
    int val = 10;

    return [[NSArray alloc] initWithObjects:^{NSLog(@"blk0:%d",val);},^{NSLog(@"blk1:%d",val);},nil];
}

    执行以上blockTest方法会出错，原因在于变量作用域。如下修改后没问题：

    - (id)getBlockArray {
    int val = 10;

    return [[NSArray alloc] initWithObjects:[^{NSLog(@"blk0:%d",val);} copy],[^{NSLog(@"blk1:%d",val);} copy],nil];
}

    注意：将Block从栈上复制到堆上是相当消耗CPU的。

    Block循环引用

    Block为何会引起循环引用

    Block中使用__strong修饰的对象类型自动变量，当Block从栈复制到堆时，该对象为Block所持有，这样容易引起循环引用。

    typedef void(^blk_t) (void);

    @interface MyObject : NSObject {
    blk_t _blk;
}

@end


@implementation MyObject

- (id)init {

    self = [super init];

    _blk = ^{
        NSLog(@"self = %@", self);//循环引用警告
        };

    return self;
}

@end


int main() {

    id o = [[MyObject alloc] init];
    NSLog(@"%@", o);

    return 0;
}

    MyObject类对象实例self持有Block，Block语法中使用了self，Block从栈复制到堆并持有所使用的self。self和Block相互持有，引起循环引用。

    __weak解决循环引用

    为避免循环引用，可声明__weak修饰的变量，并将self赋值使用。

    - (id)init {

    self = [super init];

    id __weak tmp = self;

    _blk = ^{
        NSLog(@"self = %@", tmp);
        };

    return self;
}

    __weak打破了Block对self的强引用，解决了循环引用问题。

    另外，Block内使用MyObject类的实例变量也会引起循环引用，因为会造成Block对self的间接持有。同样使用__weak可解决循环引用问题。

    typedef void(^blk_t) (void);

@interface MyObject : NSObject {
    blk_t _blk;
    id _obj;
}

@end


@implementation MyObject

- (id)init {

    self = [super init];

    id __weak tmp = _obj;

    _blk = ^{
        NSLog(@"_obj = %@", _obj);
    };

    return self;
}

@end

    __block解决循环引用

    使用__block变量也可以避免循环引用。

    typedef void(^blk_t) (void);

@interface MyObject : NSObject {
    blk_t _blk;
}

- (void)execBlock;

@end


@implementation MyObject

- (id)init {

    self = [super init];

    __block id tmp = self;

    _blk = ^{

        NSLog(@"self = %@", tmp);
        tmp = nil;
    };

    return self;
}

- (void)execBlock {
    blk();
}

@end


int main() {

    id o = [[MyObject alloc] init];
    [o execBlock];

    return 0;
}

    使用__block变量来避免循环引用注意以下两点：

    • __block变量在使用完时要被赋值nil
    • 必须执行Block

    PS：笔者认为这种方式其实是在模拟__weak功能。因为__weak修饰的变量在超出作用域销毁时会自动被赋值nil，而执行Block刚好就是促使变量被赋值nil这一操作执行。

    注意：ARC有效和无效时，__block说明符的区别很大。ARC无效时，__block说明符用来避免Block中的循环引用，因为有__block说明符的变量不会被retain。

    以上为Block篇的学习内容。

    相关文章

      网友评论

          本文标题：Objective-C高级编程（中）：Block

          本文链接：https://www.haomeiwen.com/subject/dcjlzftx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|Objective-C高级编程（中）：Block|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！