OC-Block的本质(四)——__block的变量的内存管理分析

image-20210425144930404

image-20210425144952426

image-20210425145018734

image-20210425145043402

image-20210425145117904

image-20210425145138231

__block的使用

typedef void (^MJBlock)(void);

int main(int argc, const char * argv[]) {
        @autoreleasepool {
        int age = 10;
        MJBlock block1 = ^{
            age = 20;
        };
    }
    return 0;
}

image-20210425143321853

Variable is not assignable (missing __block type specifier)

在block内部是无法修改局部变量的.

怎么样才能在block内部修改外部变量呢?有三种方法:
1:使用static修饰age
2:把age变成全局变量
3:使用__block修饰age

如果想在block内部修改从外部捕获的auto变量的值，加上关键字__block。代码如下

typedef void (^MJBlock)(void);

int main(int argc, const char * argv[]) {
     @autoreleasepool {
        __block int age = 10;
        MJBlock block1 = ^{
            age = 20;
            NSLog(@"age is %d", age);
        };
        block1();
        NSLog(@"%@", [block1 class]);
        NSLog(@"MJBlock执行完之后，age = %d",age);
    }
    return 0;
}

RUN>
*********************** 运行结果 **************************
2021-04-25 14:45:23.221612+0800 Interview04-__block[2888:128162] age is 20
2021-04-25 14:45:23.222238+0800 Interview04-__block[2888:128162] __NSMallocBlock__
2021-04-25 14:45:23.222320+0800 Interview04-__block[2888:128162] MJBlock执行完之后，age = 20    
__block只可以用来作用于auto变量，它的目的就是为了能够让auto变量能够在block内部内修改。全局变量和static变量本来就可以从block内部进行修改，因此__block对它们来说没有意义，所以__block被规定只能用于修饰auto变量，这一点应该不难理解。

__block的本质

我们把使用__block修饰的age转换为C++代码

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m -o main-arm64.cpp

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  __Block_byref_age_0 *age; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_age_0 *_age, int flags=0) : age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  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};

为了对比，加入一个非__block修饰的变量来做对比参考

int main(int argc, const char * argv[]) {   
   @autoreleasepool {
        __block int age = 10;
        int noblock = 30;//普通auto对象
        MJBlock block1 = ^{
            age = 20;
            NSLog(@"age is %d", age);
            NSLog(@"age is %d", noblock);
        };
        block1();
        NSLog(@"%@", [block1 class]);
        NSLog(@"MJBlock执行完之后，age = %d",age);
    }
    return 0;
}

转化C++后的代码

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int noblock;
  __Block_byref_age_0 *age; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _noblock, __Block_byref_age_0 *_age, int flags=0) : noblock(_noblock), age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};

基本类型的auto变量被block捕获的时候，就是通过值拷贝的形式把值赋给block内部相对应的基本类型变量。而案例里面的__block int age = 10，我们可以看到在底层，系统是把int age包装到了一个叫__Block_byref_age_0的对象里面。这个对象的结构如下
struct __Block_byref_age_0 {
  void *__isa;;//有isa指针 说明是一个ocobject对象
__Block_byref_age_0 *__forwarding;//指向自身类型对象的指针
 int __flags;
 int __size;//自己所占大小
 int age;//被封装的 基本数据类型变量
};
main函数中 __Block_byref_age_0被赋了什么值
 __attribute__((__blocks__(byref))) __Block_byref_age_0 age = {(void*)0,(__Block_byref_age_0 *)&age, 0, sizeof(__Block_byref_age_0), 10};
        int noblock = 30;
image-20210425150700100

10被存储到了block内部__Block_byref_age_0对象的成员变量int age上。

__Block_byref_age_0对象里面的成员变量__forwarding实际上指向了__Block_byref_age_0对象自身。

image-20210425151037568

在看看blcok内部函数操作

static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_age_0 *age = __cself->age; // bound by ref
  int noblock = __cself->noblock; // bound by copy

            (age->__forwarding->age) = 20;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_yh_qjzhl57s63j2m9l4frv27zjc0000gn_T_main_86e9d7_mi_0, (age->__forwarding->age));
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_yh_qjzhl57s63j2m9l4frv27zjc0000gn_T_main_86e9d7_mi_1, noblock);
        }

image-20210425151755842

block内部修改auto变量,是先通过参数传递进来的block找到age结构体,然后通过age结构体找到__forwarding成员,通过之前的分析已经知道__forwarding存储的指针指向age结构体自己,所以本质上还是通过age结构体找到存储auto变量值得age成员,然后修改成 20.

为什么用age->__forwarding->age，而不是age->age直接拿到int age，通过__forwarding转一圈有什么用意？

为什么苹果要设计forwarding这种多此一举的方式呢?

因为当block从栈上拷贝到堆上后,__block变量也会拷贝到堆上.这时就有两份__block变量,一份栈上的,一份堆上的.如果__block修饰的变量是存放在栈上,这是forwarding指向的是它自己,这样没有问题.但是如果__block修饰的变量复制到堆上,它就会把栈上的forwarding指向堆上的变量,这样就能保证即使访问栈上的__block变量也能获取到堆上的变量值,如图:

img

上面，我们知道了通过 __block int age = 10定义之后，这个a底层是一个__Block_byref_age_0对象，数值10存放在这个对象内部的成员变量int age上面。但是我们在写代码的时候，可以直接通过__Block_byref_age_0对象age来赋值，那么在block定义初始化结束，完成变量捕获之后，oc代码中再次通过age访问到的到底是什么呢？如下图所示

image-20210425152652641

#import <Foundation/Foundation.h>

typedef void (^MJBlock) (void);

struct __Block_byref_age_0 {
    void *__isa;
    struct __Block_byref_age_0 *__forwarding;
    int __flags;
    int __size;
    int age;
};

struct __main_block_desc_0 {
    size_t reserved;
    size_t Block_size;
    void (*copy)(void);
    void (*dispose)(void);
};

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

struct __main_block_impl_0 {
    struct __block_impl impl;
    struct __main_block_desc_0* Desc;
    struct __Block_byref_age_0 *age;
};

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        __block int age = 10;
        
        MJBlock block = ^{
            age = 20;
            NSLog(@"age is %d", age);
        };
        
        struct __main_block_impl_0 *blockImpl = (__bridge struct __main_block_impl_0 *)block;
        
        NSLog(@"%@", [block class]);
        NSLog(@"MJBlock执行完之后，age = %d",age);
        NSLog(@"完成变量捕获之后，其内部的[__Block_byref_age_0 *] a = %p",blockImpl->age);
        NSLog(@"oc代码里直接通过a访问的内存空间是：%p",&age);
    }
    return 0;
}

RUN>
*********************** 运行结果 **************************
2021-04-25 15:32:06.386047+0800 Interview01-__block[3197:151003] __NSMallocBlock__
2021-04-25 15:32:06.386544+0800 Interview01-__block[3197:151003] MJBlock执行完之后，age = 10
2021-04-25 15:32:06.386602+0800 Interview01-__block[3197:151003] 完成变量捕获之后，其内部的[__Block_byref_age_0 *] a = 0x1004b9230
2021-04-25 15:32:06.386641+0800 Interview01-__block[3197:151003] oc代码里直接通过a访问的内存空间是：0x1004b9248
image-20210425153709926

image-20210425155044976

block内部的[__Block_byref_age_0 *] age指向的地址是0x1004b9230，之后我们在任意地方通过age访问的内存地址是0x1004b9248，十六进制下它们地址相差了0x18，也就是十进制下的24个字节。
struct __Block_byref_age_0 {
    void *__isa;  //8
    struct __Block_byref_age_0 *__forwarding; //8
    int __flags;//4
    int __size;//4
    int age;
};
8+8+4+4 = 24;

也就是说我们在oc代码里面完成了block的初始化以及 __block变量的捕获之后，只能通过age访问到被封装在 __ Block_byref_age_0 * 内部的这个int age的内存空间。

我们思考一下苹果为什么这样设计?因为苹果要隐藏它内部的实现,我们在修改__block修饰的age的值时,从表面看会以为真的是在直接修改age的值,如果不了解底层实现的话,根本就不知道被__block修饰的age已经被包装成了一个对象,而我们实际修改的是age结构体中的age成员的值.

__block变量的内存管理

block捕获对象类型的auto变量就会多出两个函数用于做内存管理操作(__main_block_copy_0和__main_block_dispose_0)，如下：

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

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

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  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};

block也会使用这两个函数管理__block修饰的变量的内存，这也从侧面证明"编译器会将__block变量包装成一个对象"，这句话是对的，因为只有对象才需要内存管理。

现在我们来研究一下,使用__block修饰的外部变量,在block内部是如何管理的.

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        __block int age = 10;
        int noblock = 30;
        
        MJBlock myblock = ^{
            age = 20;
            NSLog(@"age is %d", age);
            NSLog(@"noblock is %d", noblock);
        };
        myblock();
       
        
        NSLog(@"%@", [myblock class]);


    }
    return 0;
}

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  void (*dispose)(struct __main_block_impl_0*);
}

会发现同访问了对象类型的变量一样,__main_block_desc_0结构体中同样有copy,dispose函数

为什么访问 __block int 时也会产生呢?

在上面我们说过,block在访问__block修饰的变量时,其底层会被封装成__Block_byref_age_0类型,在这个类型存在一个void *__isa成员,所以本质上它就是一个对象类型.

__block修饰的变量的内存管理：

当block在栈上时，并不会对__block变量产生强引用
当block被copy到堆时（自己拷贝的或者ARC下系统自动拷贝的）
会调用block内部的copy函数
copy函数内部会调用_Block_object_assign函数
_Block_object_assign函数会对__block变量形成强引用（retain）

img

关于内存管理问题这里，我们所讨论的问题需要考虑三个关键因素：__block、__weak、对象变量、基本类型变量，他们合法的组合有如下几种：

基本类型变量
对象变量
__weak + 对象变量
__block + 基本类型变量
__block + 对象变量
__block + __weak + 对象变量

在OC-Block的本质(三)-对象类型的auto变量这一篇里面详细分析了一个对象类型的auto变量被block捕获时的内存管理过程，上面的1、2、3这三种场景已经得到了说明。下面我们来分析一下4、5、6这三种场景。

`__block` + `基本类型变量`

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        __block int age = 10;
        int noblock = 30;
        
        MJBlock myblock = ^{
            age = 20;
            NSLog(@"age is %d", age);
            NSLog(@"noblock is %d", noblock);
        };
        myblock();
       
        
        NSLog(@"%@", [myblock class]);


    }
    return 0;
}

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m -o main-arm64.cpp

转化后的c++源码

struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
  int noblock;
  __Block_byref_age_0 *age; // by ref
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, int _noblock, __Block_byref_age_0 *_age, int flags=0) : noblock(_noblock), age(_age->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself) {
  __Block_byref_age_0 *age = __cself->age; // bound by ref
  int noblock = __cself->noblock; // bound by copy

            (age->__forwarding->age) = 20;
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_yh_qjzhl57s63j2m9l4frv27zjc0000gn_T_main_f68719_mi_0, (age->__forwarding->age));
            NSLog((NSString *)&__NSConstantStringImpl__var_folders_yh_qjzhl57s63j2m9l4frv27zjc0000gn_T_main_f68719_mi_1, noblock);
        }
static void __main_block_copy_0(struct __main_block_impl_0*dst, struct __main_block_impl_0*src) {_Block_object_assign((void*)&dst->age, (void*)src->age, 8/*BLOCK_FIELD_IS_BYREF*/);}

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

static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  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};

我们知道__block int age = 10;这句代码的作用，是将int age包装在struct __Block_byref_age_0内部，这样block实际上捕获的是这个struct __Block_byref_age_0，它可以被当作一个对象来看待，所以内存管理上面，最终仍然是通过_Block_object_assign和_Block_object_dispose这两个函数来处理，但是可以看到这两个函数的最后一个参数是8（对于对象类型的捕获，传递的参数是3），这个参数表明了即将要处理的是一个struct __Block_byref_age_0，因为它是没有__weak和__strong标记的，所以处理方式很简单，就是copy到堆上的时候，同时需要进行retain，dispose的时候同时需要进行release。

img

img

而当block从堆中移除时:
1:调用block内部的dispose函数
2:dispose函数会调用_Block_object_dispose函数
3:_Block_object_dipose函数会自动释放引用的__block变量(release)

img

img

既然 block 访问对象类型的变量和访问使用 __block 修饰的变量都会增加copy,dispose函数,那么他们之间有没有区别呢?

他们之间的区别就是:

如果使用__block修饰的变量,block内部直接对其强引用

如果是对象类型的变量,会根据变量的修饰符__weak , __strong来决定是否强引用

`__block` + `对象变量`

#import <Foundation/Foundation.h>

@interface MJPerson : NSObject

@end
    
@implementation MJPerson
- (void)dealloc
{
    NSLog(@"%s", __func__);
}
@end

typedef void (^MJBlock) (void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        MJPerson *person = [[MJPerson alloc] init];
        __block MJPerson *blockPerson = person;
        
        MJBlock block = ^{
            NSLog(@"%p", blockPerson);
        } ;
        
       
        NSLog(@"%@", [block class]);
        block();
        
       
    }
    return 0;
}

RUN>

*********************** 运行结果 **************************
2021-04-25 17:49:33.467580+0800 Interview01-__block[4123:185220] __NSMallocBlock__
2021-04-25 17:49:33.468013+0800 Interview01-__block[4123:185220] 0x10061e4d0
2021-04-25 17:49:33.468078+0800 Interview01-__block[4123:185220] -[MJPerson dealloc]

编译

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m -o main-arm64.cpp

编译之后， __block MJPerson *blockPerson的底层结构如下

struct __Block_byref_blockPerson_0 {
  void *__isa;
__Block_byref_blockPerson_0 *__forwarding;
 int __flags;
 int __size;
 void (*__Block_byref_id_object_copy)(void*, void*);
 void (*__Block_byref_id_object_dispose)(void*);
 MJPerson *__strong blockPerson;
};

可以看到使用__block修饰的对象底层被封装成了__Block_byref_blockPerson_0类型的对象,__Block_byref_blockPerson_0这个对象类型的结构体中有一个MJPerson *__strong blockPerson成员,强引用着我们在main函数中创建的MJPerson对象,而__main_block_impl_0中的blockPerson又强引用着__Block_byref_blockPerson_0对象,他们的关系如下图:

__block修饰对象类型

image-20210425175504533

从这个结构可以看出两点变化：

相比较基本类型变量，对象类型的变量被__block修饰后，底层所生成的__Block_byref_xxx_x结构体里面多了两个函数指针，__Block_byref_id_object_copy和__Block_byref_id_object_dispose。

对象类型的变量被封装到__Block_byref_xxx_x内部以后，默认是被__strong修饰的。

上面发现的两个新函数指针__Block_byref_id_object_copy和__Block_byref_id_object_dispose就是当__Block_byref_xxx_x被拷贝到堆空间的时候，以及将要被系统释放的时候调用的。

image-20210425175825419

它们的定义如下:
#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)
static void __Block_byref_id_object_copy_131(void *dst, void *src) {
 _Block_object_assign((char*)dst + 40, *(void * *) ((char*)src + 40), 131);
}
static void __Block_byref_id_object_dispose_131(void *src) {
 _Block_object_dispose(*(void * *) ((char*)src + 40), 131);
}
最终还是调用了_Block_object_assign和_Block_object_assign这两个函数，二从参数可以看出，它们所要处理的对象就是__Block_byref_id_object_dispose内部所封装的对象类型变量，也就是我们代码中的MJPerson *blockPerson，因为默认blockPerson是被__strong修饰的，所以接下来对于blockPerson的内存管理方式就和我们之前所分析过的是一样的。

`block` + `weak` + `对象变量`

#import <Foundation/Foundation.h>
#import "MJPerson.h"

typedef void (^MJBlock) (void);

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        MJPerson *person = [[MJPerson alloc] init];
        __block __weak MJPerson *blockPerson = person;
        
        MJBlock block = ^{
            NSLog(@"%p", blockPerson);
        } ;
        
       
        NSLog(@"%@", [block class]);
        block();
        
       
    }
    return 0;
}

RUN>

2021-04-25 20:05:06.334104+0800 Interview01-__block[4591:204724] __NSMallocBlock__
2021-04-25 20:05:06.334480+0800 Interview01-__block[4591:204724] 0x10051edc0
2021-04-25 20:05:06.334534+0800 Interview01-__block[4591:204724] -[MJPerson dealloc]

查看底层代码:

xcrun -sdk iphoneos clang -arch arm64 -rewrite-objc -fobjc-arc -fobjc-runtime=ios-8.0.0 main.m -o main-arm64.cpp

typedef void (*MJBlock) (void);

struct __Block_byref_blockPerson_0 {// __block 底层对象
  void *__isa;//8
__Block_byref_blockPerson_0 *__forwarding;//8
 int __flags;//4
 int __size;//4
 void (*__Block_byref_id_object_copy)(void*, void*);//8
 void (*__Block_byref_id_object_dispose)(void*);//8
 MJPerson *__weak blockPerson;//这里变成了弱引用,说明这里的引用情况取决于外部变量的修饰符
};
// block 底层对象
struct __main_block_impl_0 {
  struct __block_impl impl;
  struct __main_block_desc_0* Desc;
    //这里还是强引用,说明 __weak 关键字并不会影响这里
  __Block_byref_blockPerson_0 *blockPerson; // by ref 
  __main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, __Block_byref_blockPerson_0 *_blockPerson, int flags=0) : blockPerson(_blockPerson->__forwarding) {
    impl.isa = &_NSConcreteStackBlock;
    impl.Flags = flags;
    impl.FuncPtr = fp;
    Desc = desc;
  }
};
static struct __main_block_desc_0 {
  size_t reserved;
  size_t Block_size;
  void (*copy)(struct __main_block_impl_0*, struct __main_block_impl_0*);
  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};

查看底层代码我们发现,block内部对于__Block_byref_blockPerson_0的引用没有变化,强指针指向__Block_byref_weakPerson_0结构体,但是__Block_byref_blockPerson_0中的blockPerson已经从强引用变成了弱引用.如图:

img

总结：

对于block：

如果block是在栈上，将不会对__Block_byref_weakPerson_0产生强引用
如果栈上的block被拷贝到堆上
_Block_object_assign函数会对__Block_byref_weakPerson_0产生强引用
如果堆上的block被移除
_Block_object_dispose函数会对__Block_byref_weakPerson_0产生弱引用或者移除

对于__block修饰的对象类型：

当__block变量在栈上时，不会对指向的对象产生强引用
当__block变量被copy到堆时（自己拷贝的或者ARC下系统自动拷贝的）
会调用__block变量内部的copy函数
copy函数内部会调用_Block_object_assign函数
_Block_object_assign函数会根据所指向对象的修饰符（__strong、__weak、__unsafe_unretained）做出相应的操作，形成强引用（retain）或者弱引用（注意：这里仅限于ARC时会retain，MRC时不会retain，一直是弱的。这个特例只会在MRC并且是__block修饰对象类型才有）
如果__block变量从堆上移除
会调用__block变量内部的dispose函数
dispose函数内部会调用_Block_object_dispose函数
_Block_object_dispose函数会自动释放指向的对象（release）

将项目切换成MRC环境

image-20210425202427509

使用__block修饰对象类型，如下：

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        
        __block MJPerson *person = [[MJPerson alloc] init];
        
        MJBlock block = [^{
            NSLog(@"%p", person);
        } copy];

        [person release];

        block();  //在此处打断点

        [block release];
    }
    return 0;
}

RUN>
*********************** 运行结果 **************************
2021-04-25 20:25:01.684799+0800 Interview01-__block[4780:216050] -[MJPerson dealloc]
2021-04-25 20:25:01.685196+0800 Interview01-__block[4780:216050] 0x1004708c0
image-20210425202848845

当block被拷贝到堆上的时候，__block修饰的person也会被拷贝到堆上，这时候会调用__block修饰的变量内部的copy函数，MRC环境下，copy函数内部只会对person对象产生弱引用。如下图：

__block修饰的对象

如果把__block去掉,会怎么样?

image-20210425203407928

如果把__block去掉,blcok 就会对 person 产生强引用,在 block 释放之前,person 是不会释放的,因为去掉__block后,就没有__Block_byref_blockPerson_0这个中间层,blcok 会直接强引用 person对象

直接引用

特别备注

本系列文章总结自MJ老师在腾讯课堂iOS底层原理班（下）/OC对象/关联对象/多线程/内存管理/性能优化，相关图片素材均取自课程中的课件。如有侵权，请联系我删除，谢谢！

OC-Block的本质(四)——__block的变量的内存管理分析

__block的使用

__block的本质

__block变量的内存管理

`__block` + `基本类型变量`

他们之间的区别就是:

`__block` + `对象变量`

`block` + `weak` + `对象变量`

总结：

特别备注

相关推荐

一个分享Java & Python知识的社区

__block的使用

__block的本质

__block变量的内存管理

__block + 基本类型变量

他们之间的区别就是:

__block + 对象变量

__block + __weak + 对象变量

总结：

特别备注

相关推荐

一个分享Java & Python知识的社区

`__block` + `基本类型变量`

`__block` + `对象变量`

`block` + `weak` + `对象变量`