《Objective-C高级编程 iOS与OS X多线程与内存管

Blocks篇：5.Blocks修改捕获到的变量（__block修饰符）

我们知道，在Block中，修改捕获变量的方式：

• 对于全局变量，由于实质上Block并未对其进行捕获，故可以直接在Block函数体内部进行变量修改；
• 对于局部的静态变量，由于Block捕获的是其指针，故可以通过指针对原变量进行修改；
• 对于普通的局部变量，由于在Block函数体内使用的版本已经不是之前的变量了（是Block结构体中保存的成员），故编译器不支持直接修改。这种情况下，只能通过“__block”修饰变量进行处理。

1.__block修饰符带来的变化

由于需修改局部变量，我们将栗子变成这个：

// main.m

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // 声明__block修饰的局部变量
        __block int val = 2;
        
        void (^myBlock)(void) = ^{
            // 捕获后修改变量的值
            val = 3;
        };
        myBlock();
    }
    return 0;
}

使用clang转换后，代码如下：

// main.cpp

/** Block数据结构体（没变） */
struct __block_impl {
    void *isa;
    int Flags;
    int Reserved;
    void *FuncPtr;
};

/** __block修饰的变量对应的结构体 */
struct __Block_byref_val_0 {
    /** 类型 */
    void *__isa;
    /** 指向自身结构体实例的指针 */
    __Block_byref_val_0 *__forwarding;
    int __flags;
    int __size;
    /** 变量真正的值 */
    int val;
};

/** Block完整结构体 */
struct __main_block_impl_0 {
    /** Block数据实例 */
    struct __block_impl impl;
    /** Block描述信息实例的指针 */
    struct __main_block_desc_0* Desc;
    /** __Block_byref_val_0实例的指针 */
    __Block_byref_val_0 *val; // by ref
    // 构造函数
    __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_val_0 *_val, int flags=0) : val(_val->__forwarding) {
        impl.isa = &_NSConcreteStackBlock;
        impl.Flags = flags;
        impl.FuncPtr = fp;
        Desc = desc;
  }
};

/** Block的函数体 */
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    // 取出保存的实例
    __Block_byref_val_0 *val = __cself->val; // bound by ref
    // 取出对应的变量真实值？？？
    (val->__forwarding->val) = 3;
}

/** __block变量对应的copy函数（复制Block对象时调用） */
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);
}

/** __block变量对应的dispose函数（释放Block对象时调用） */
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);
}

/** Block描述信息结构体实例 */
static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
    /** copy函数指针 */
    void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
    /** dispose函数指针 */
    void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 
    0, 
    sizeof(struct __main_block_impl_0), 
    __main_block_copy_0, // 赋值函数
    __main_block_dispose_0 // 赋值函数
};


// main函数
int main(int argc, const char * argv[]) {
    /* @autoreleasepool */ 
    { 
        __AtAutoreleasePool __autoreleasepool; 
        
        // 创建__block变量对应的__Block_byref_val_0结构体实例
        // （__attribute__部分表示需要变量为栈上的变量？？？）
        __attribute__((__blocks__(byref))) __Block_byref_val_0 val = {
            (void*)0,
            (__Block_byref_val_0 *)&val, // 指向自身实例
            0, 
            sizeof(__Block_byref_val_0), 
            2 // 真正的值
        };
        
        // 创建Block对象，并使用函数指针指向它
        void (*myBlock)(void) = (
            (void (*)())&__main_block_impl_0(
                (void *)__main_block_func_0, // 函数指针
                &__main_block_desc_0_DATA, // 描述信息实例指针
                (__Block_byref_val_0 *)&val, // 变量实例指针
                570425344
            )
        );
        
        // 调用Block中的函数
        ((void (*)(__block_impl *))((__block_impl *)myBlock)->FuncPtr)((__block_impl *)myBlock);
    }
    return 0;
}

在代码中可以看到，

1. 使用__block修饰的变量，由基本变量转变成了结构体实例；
2. 当Block使用时，Block需要在其结构中保存此结构体实例的指针；
3. 提供了copy和dispose函数用于管理捕获的__block变量的内存。

2.__block变量的存储规则

我们知道，当Block对象捕获变量后，ARC会自动将其复制到堆内存中。此时，被捕获的__block变量又会如何变化呢？

__block变量本身的存储域	Block从栈复制到堆时的影响
栈	复制到堆内存中
堆	被该Block持有

由上表可得出结论：

1. 在Block捕获了__block变量的情况下，当Block在堆内存中生成后，该变量也会被自动拷贝到堆内存中，并继续被Block对象所持有。
2. __block变量的内存管理非常类似于引用计数的管理方式：被_NSConcreteMallocBlock对象持有时，变量存在；当没有被任何Block持有后，被系统释放。

现在，我们就可以来解释一下之前的疑问：为何__block变量内部存在指向自身结构实例的__forwarding指针；且取值或修改时，需要通过此指针取出val的值？

2.1 __block变量可以在Block内或外部随意修改

开门见山，直接给出原因：

__block变量通过__forwarding可以从任意内存区域访问同一块内存。

我们先来回顾一下__block变量在栈中的大体结构：

存储在栈中的__block变量结构.jpg

1. 我们知道，在普通情况下，Block函数体中的捕获变量是通过值传递复制进去的，其执行时，原变量早已释放；若需要同时可以访问或修改，必然需要该变量为同一块内存。
2. 故__block变量能够同时修改的原因，必然是在栈和堆中同时存在相同的变量指针，指向同一块内存。所以，根据存储规则，当栈__block变量被复制到堆内存时，原变量的__forwarding指针必然需要指向堆变量，以满足此目的。

复制到堆后__block变量的结构.jpg

此时，无论是从栈中或是堆中访问__block变量，均可以通过__forwarding指针来访问到真正的变量值。如之前的Block函数体：

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
    // 取出保存的实例
    __Block_byref_val_0 *val = __cself->val; // bound by ref
    // 通过__forwarding获取真正的变量实例，并取值
    (val->__forwarding->val) = 3;
}

在Block函数体中，由于val已经是堆__block变量，故其__forwarding指针指向自身，可以成功取到变量值。

而在Block外，直接访问或修改val的值：

val += 1;

其转换后的代码为：

val->__forwarding->val += 1;

此时，栈变量val的__forwarding指针指向堆变量val，故其val与在堆中直接访问相同，均指向同一个val的地址。

3.Block对象对捕获到的__block变量进行内存管理

在上述实例中，Block对象的描述结构指定了copy和dispose两个函数：

/** copy函数 */
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {
    _Block_object_assign((void*)&dst->val, (void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);
}

/** dispose函数 */
static void __main_block_dispose_0(struct __main_block_impl_0*src) {
    _Block_object_dispose((void*)src->val, 8/*BLOCK_FIELD_IS_BYREF*/);
}

static struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
    /** copy指针 */
    void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
    /** dispose指针 */
    void (*dispose)(struct __main_block_impl_0*);
} __main_block_desc_0_DATA = { 
    0, 
    sizeof(struct __main_block_impl_0),
    /** copy指针 */
    __main_block_copy_0, 
    /** dispose指针 */
    __main_block_dispose_0
};

其中，

• copy方法即为由_NSConcreteStackBlock对象copy生成_NSConcreteMallocBlock对象过程中进行的函数调用。这里即对捕获的__block变量进行指针复制（传递引用）。
• dispose方法为_NSConcreteMallocBlock对象释放时进行调用，内部即对捕获的__block变量进行释放操作，不再保留。

栈Block复制为堆Block的过程.jpg

因此，经过此过程，堆内存中的Block对象强引用着同样处于堆内存中的__block变量；当自身释放时，被保留的__block变量的强引用失效。