block没那么难(三)
2015-08-14 21:32
423 查看
block没那么难(三):block和对象的内存管理 - 作业部落 Cmd Markdown 编辑阅读器
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-44461741-1', 'zybuluo.com');
ga('send', 'pageview');
[关闭]
本系列博文总结自《Pro Multithreading and Memory Management for iOS and OS X with ARC》
如果您觉得我的博客对您有帮助,请通过关注我的新浪微博 [/i] MicroCai 支持我,谢谢!
在上一篇文章中,我们讲了很多关于 block 和基础变量的内存管理,接着我们聊聊 block 和对象的内存管理,如 block 经常会碰到的循环引用问题等等。
[/code]
翻译后的关键代码摘录如下
[/code]
在本例中,当变量变量作用域结束时,
总结代码可正常运行的原因关键就在于 block 通过调用
在以下情形中, block 会从栈拷贝到堆:
当 block 调用
当 block 作为函数返回值返回时,编译器自动将 block 作为
当 block 被赋值给 __strong id 类型的对象或 block 的成员变量时,编译器自动将 block 作为
当 block 作为参数被传入方法名带有
其实后三种情况在上篇文章block的自动拷贝已经做过说明
除此之外,都需要手动调用。
延伸阅读:Objective-C 结构体中的 __strong 成员变量
注意到
通常情况下, Objective-C 的编译器因为无法检测 C 结构体初始化和释放的时间,不能进行有效的内存管理,所以 Objective-C 的 C 结构体成员是不能用
[/code]
ARC 下,对象所有权修饰符默认为
[/code]
[/code]
所以,只要是堆上的
如果上面的
[/code]
结果是:
[/code]
原因很简单,
如果
如果
[/code]
编译器就会报下面的错误,意思就是
error: __block variables cannot have __autoreleasing ownership __block id __autoreleasing obj = [[NSObject alloc] init];
愉快的代码时间到
[/code]
由于
由于循环引用的存在,造成在
warning: capturing ‘self’ strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]
blk_ = ^{NSLog(@”self = %@”, self);};
note: Block will be retained by an object strongly retained by the captured object
blk_ = ^{NSLog(@”self = %@”, self);};
为了避免这种情况发生,可以在变量声明时用
[/code]
再看一个例子
[/code]
上面的例子中,虽然没有直接使用 self,却也存在循环引用的问题。因为对于编译器来说,
[/code]
所以这个例子只要用
[/code]
破解循环引用还有一招,使用 __block 修饰对象,在 block 内将对象置为 nil 即可,如下
[/code]
这个例子挺有意思的,如果执行
还有个值得一提的时,在 MRC 下,使用 __block 说明符也可以避免循环引用。因为当 block 从栈拷贝到堆时,__block 对象类型的变量不会被 retain,没有 __block 说明符的对象类型的变量则会被 retian。正是由于 __block 在 ARC 和 MRC 下的巨大差异,我们在写代码时一定要区分清楚到底是 ARC 还是 MRC。
尽管 ARC 已经如此普及,我们可能已经可以不用去管 MRC 的东西,但要有点一定要明白,ARC 和 MRC 都是基于引用计数的内存管理,其本质上是一个东西,只不过 ARC 在编译期自动化的做了内存引用计数的管理,使得系统可以在适当的时候保留内存,适当的时候释放内存。
循环引用到此为止,东西并不多。如果明白了之前的知识点,就会了解循环引用不过是前面知识点的自然延伸点罢了。
[/code]
拷贝到堆后,就可以 用
[/code]
然而如果 block 在栈上,使用
block 是 C 语言的扩展,所以可以在 C 中使用 block 的语法。比如,在上面的例子中,可以直接使用
[/code]
最后这里有一篇总结 block 的文章的很不错,推荐大家看看:http://tanqisen.github.io/blog/2013/04/19/gcd-block-cycle-retain/
获取对象
__block 变量和对象
循环引用
Copy 和 Release
内容目录
[/i]About-Blog
1
[/i]
MicroCai 的博客
[/i]Archives
18
[/i]
* 客户端实现负载均衡
[/i]
问题记录:iOS 用户行为统计代码的剥离
[/i]
[译] 照片框架
[/i]
Autolayout 基础
[/i]
ARC 下内存泄露的那些点
[/i]
KVO 和 KVC 的使用和实现
[/i]
iOS Events and Responder Chain
[/i]
两个超大整数相加
[/i]
Effective Objective-C Notes:GCD 实现同步锁
[/i]
Effective Objective-C Notes:理解类对象
[/i]
Effective Objective-C Notes:理解消息传递机制
[/i]
Effective Objective-C Notes:Objective-C命名规范
[/i]
Effective Objective-C Notes:概览
[/i]
block没那么难(三):block和对象的内存管理
[/i]
block没那么难(二):block和变量的内存管理
[/i]
block没那么难(一):block的实现
[/i]
iOS 集合的深复制与浅复制
[/i]
[译] Block 小测验
[/i]iOS
17
[/i]
* 客户端实现负载均衡
[/i]
问题记录:iOS 用户行为统计代码的剥离
[/i]
[译] 照片框架
[/i]
Autolayout 基础
[/i]
ARC 下内存泄露的那些点
[/i]
KVO 和 KVC 的使用和实现
[/i]
iOS Events and Responder Chain
[/i]
Effective Objective-C Notes:GCD 实现同步锁
[/i]
Effective Objective-C Notes:理解类对象
[/i]
Effective Objective-C Notes:理解消息传递机制
[/i]
Effective Objective-C Notes:Objective-C命名规范
[/i]
Effective Objective-C Notes:概览
[/i]
block没那么难(三):block和对象的内存管理
[/i]
block没那么难(二):block和变量的内存管理
[/i]
block没那么难(一):block的实现
[/i]
iOS 集合的深复制与浅复制
[/i]
[译] Block 小测验
[/i]翻译
2
[/i]
[译] 照片框架
[/i]
[译] Block 小测验
[/i]计算机基础
5
[/i]
进程间通信的方式
[/i]
排序算法整理
[/i]
算法的时间复杂度
[/i]
HTTP 请求基础
[/i]
RESTful 与 HTTP
[/i]趣味题
1
[/i]
两个超大整数相加
[/i]
[/i]
以下【标签】将用于标记这篇文稿:
[/i]下载客户端
[/i]关注开发者
[/i]报告问题,建议
[/i]联系我们
添加新批注
在作者公开此批注前,只有你和作者可见。
保存
取消
修改
保存
取消
删除
私有
公开
删除
查看更早的 5 条回复
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-44461741-1', 'zybuluo.com');
ga('send', 'pageview');
[关闭]
@MicroCai
2015-06-27T05:49:54.000000Z
字数 7904
阅读 1418
block没那么难(三):block和对象的内存管理
Archives
iOS
本系列博文总结自《Pro Multithreading and Memory Management for iOS and OS X with ARC》
如果您觉得我的博客对您有帮助,请通过关注我的新浪微博 [/i] MicroCai 支持我,谢谢!
在上一篇文章中,我们讲了很多关于 block 和基础变量的内存管理,接着我们聊聊 block 和对象的内存管理,如 block 经常会碰到的循环引用问题等等。
获取对象
照例先来段代码轻松下,瞧瞧 block 是怎么获取外部对象的[code]/********************** capturing objects **********************/
typedef void (^blk_t)(id obj);
blk_t blk;
- (void)viewDidLoad
{
[self captureObject];
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
}
- (void)captureObject
{
id array = [[NSMutableArray alloc] init];
blk = [^(id obj) {
[array addObject:obj];
NSLog(@"array count = %ld", [array count]);
}copy];
}
[/code]
翻译后的关键代码摘录如下
[code]/* a struct for the Block and some functions */
struct __main_block_impl_0
{
struct __block_impl impl;
struct __main_block_desc_0 *Desc;
id __strong array;
__main_block_impl_0(void *fp, struct __main_block_desc_0 *desc, id __strong _array, int flags=0) : array(_array)
{
impl.isa = &_NSConcreteStackBlock;
impl.Flags = flags;
impl.FuncPtr = fp;
Desc = desc;
}
};
static void __main_block_func_0(struct __main_block_impl_0 *__cself, id obj)
{
id __strong array = __cself->array;
[array addObject:obj];
NSLog(@"array count = %ld", [array count]);
}
static void __main_block_copy_0(struct __main_block_impl_0 *dst, __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);
}
struct static struct __main_block_desc_0
{
unsigned long reserved;
unsigned long 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 literal and executing the Block */
blk_t blk;
{
id __strong array = [[NSMutableArray alloc] init];
blk = &__main_block_impl_0(__main_block_func_0,
&__main_block_desc_0_DATA,
array,
0x22000000);
blk = [blk copy];
}
(*blk->impl.FuncPtr)(blk, [[NSObject alloc] init]);
(*blk->impl.FuncPtr)(blk, [[NSObject alloc] init]);
(*blk->impl.FuncPtr)(blk, [[NSObject alloc] init]);
[/code]
在本例中,当变量变量作用域结束时,
array被废弃,强引用失效,
NSMutableArray类的实例对象会被释放并废弃。在这危难关头,block 及时调用了
copy方法,在
_Block_object_assign中,将
array赋值给 block 成员变量并持有。所以上面代码可以正常运行,打印出来的
array count依次递增。
总结代码可正常运行的原因关键就在于 block 通过调用
copy方法,持有了 __strong 修饰的外部变量,使得外部对象在超出其作用域后得以继续存活,代码正常执行。
在以下情形中, block 会从栈拷贝到堆:
当 block 调用
copy方法时,如果 block 在栈上,会被拷贝到堆上;
当 block 作为函数返回值返回时,编译器自动将 block 作为
_Block_copy函数,效果等同于 block 直接调用
copy方法;
当 block 被赋值给 __strong id 类型的对象或 block 的成员变量时,编译器自动将 block 作为
_Block_copy函数,效果等同于 block 直接调用
copy方法;
当 block 作为参数被传入方法名带有
usingBlock的 Cocoa Framework 方法或 GCD 的 API 时。这些方法会在内部对传递进来的 block 调用
copy或
_Block_copy进行拷贝;
其实后三种情况在上篇文章block的自动拷贝已经做过说明
除此之外,都需要手动调用。
延伸阅读:Objective-C 结构体中的 __strong 成员变量
注意到
__main_block_impl_0结构体有什么异常没?在 C 结构体中出现了
__strong关键字修饰的变量。
通常情况下, Objective-C 的编译器因为无法检测 C 结构体初始化和释放的时间,不能进行有效的内存管理,所以 Objective-C 的 C 结构体成员是不能用
__strong、
__weak等等这类关键字修饰。然而 runtime 库是可以在运行时检测到 block 的内存变化,如 block 何时从栈拷贝到堆,何时从堆上释放等等,所以就会出现上述结构体成员变量用
__strong修饰的情况。
__block 变量和对象
__block 说明符可以修饰任何类型的自动变量。下面让我们再看个小例子,啊,愉快的代码时间又到啦。[code]/******* block 修饰对象 *******/
__block id obj = [[NSObject alloc] init];
[/code]
ARC 下,对象所有权修饰符默认为
__strong,即
[code]__block id __strong obj = [[NSObject alloc] init];
[/code]
[code]/******* block 修饰对象转换后的代码 *******/
/* struct for __block variable */
struct __Block_byref_obj_0
{
void *__isa;
__Block_byref_obj_0 *__forwarding;
int __flags;
int __size;
void (*__Block_byref_id_object_copy)(void*, void*);
void (*__Block_byref_id_object_dispose)(void*);
__strong id obj;
};
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 variable declaration */
__Block_byref_obj_0 obj = { 0,
&obj,
0x2000000,
sizeof(__Block_byref_obj_0),
__Block_byref_id_object_copy_131,
__Block_byref_id_object_dispose_131,
[[NSObject alloc] init]
};
[/code]
__block id __strong obj的作用和
id __strong obj的作用十分类似。当
__block id __strong obj从栈上拷贝到堆上时,
_Block_object_assign被调用,block 持有
obj;当
__block id __strong obj从堆上被废弃时,
_Block_object_dispose被调用用以释放此对象,block 引用消失。
所以,只要是堆上的
__strong修饰符修饰的
__block对象类型的变量,和 block 内获取到的
__strong修饰符修饰的对象类型的变量,编译器都能对它们的内存进行适当的管理。
如果上面的
__strong换成
__weak,结果会怎样呢?
[code]/********************** capturing __weak objects **********************/
typedef void (^blk_t)(id obj);
blk_t blk;
- (void)viewDidLoad
{
[self captureObject];
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
blk([[NSObject alloc] init]);
}
- (void)captureObject
{
id array = [[NSMutableArray alloc] init];
id __weak array2 = array;
blk = [^(id obj) {
[array2 addObject:obj];
NSLog(@"array2 count = %ld", [array2 count]);
}copy];
}
[/code]
结果是:
[code]array2 count = 0
array2 count = 0
array2 count = 0
[/code]
原因很简单,
array2是弱引用,当变量作用域结束,
array所指向的对象内存被释放,
array2指向 nil,向 nil 对象发送
count消息就返回结果 0 了。
如果
__weak再改成
__unsafe_unretained呢?
__unsafe_unretained修饰的对象变量指针就相当于一个普通指针。使用这个修饰符有点需要注意的地方是,当指针所指向的对象内存被释放时,指针变量不会被置为 nil。所以当使用这个修饰符时,一定要注意不要通过悬挂指针(指向被废弃内存的指针)来访问已经被废弃的对象内存,否则程序就会崩溃。
如果
__unsafe_unretained再改成
__autoreleasing会怎样呢?会报错,编译器并不允许你这么干!如果你这么写
[code]__block id __autoreleasing obj = [[NSObject alloc] init];
[/code]
编译器就会报下面的错误,意思就是
__block和
__autoreleasing不能同时使用。
error: __block variables cannot have __autoreleasing ownership __block id __autoreleasing obj = [[NSObject alloc] init];
循环引用
千辛万苦,重头戏终于来了。block 如果使用不小心,就容易出现循环引用,导致内存泄露。到底哪里泄露了呢?通过前面的学习,各位童鞋应该有个底了,下面就让我们一起进入这泄露地区瞧瞧,哪儿出了问题!愉快的代码时间到
[code]// ARC enabled
/************** MyObject Class **************/
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;
}
- (void)dealloc
{
NSLog(@"dealloc");
}
@end
/************** main function **************/
int main()
{
id myObject = [[MyObject alloc] init];
NSLog(@"%@", myObject);
return 0;
}
[/code]
由于
self是
__strong修饰,在 ARC 下,当编译器自动将代码中的 block 从栈拷贝到堆时,block 会强引用和持有
self,而
self恰好也强引用和持有了 block,就造成了传说中的循环引用。
由于循环引用的存在,造成在
main()函数结束时,内存仍然无法释放,即内存泄露。编译器也会给出警告信息
warning: capturing ‘self’ strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]
blk_ = ^{NSLog(@”self = %@”, self);};
note: Block will be retained by an object strongly retained by the captured object
blk_ = ^{NSLog(@”self = %@”, self);};
为了避免这种情况发生,可以在变量声明时用
__weak修饰符修饰变量
self,让 block 不强引用
self,从而破除循环。iOS4 和 Snow Leopard 由于对 weak 的支持不够完全,可以用
__unsafe_unretained代替。
[code]- (id)init
{
self = [super init];
id __weak tmp = self;
blk_ = ^{NSLog(@"self = %@", tmp);};
return self;
}
[/code]
再看一个例子
[code]@interface MyObject : NSObject
{
blk_t blk_;
id obj_;
}
@end
@implementation MyObject
- (id)init
{
self = [super init];
blk_ = ^{ NSLog(@"obj_ = %@", obj_); };
return self;
}
...
...
@end
[/code]
上面的例子中,虽然没有直接使用 self,却也存在循环引用的问题。因为对于编译器来说,
obj_就相当于
self->obj_,所以上面的代码就会变成
[code]blk_ = ^{ NSLog(@"obj_ = %@", self->obj_); };
[/code]
所以这个例子只要用
__weak,在
init方法里面加一行即可
[code]id __weak obj = obj_;
[/code]
破解循环引用还有一招,使用 __block 修饰对象,在 block 内将对象置为 nil 即可,如下
[code]typedef void (^blk_t)(void);
@interface MyObject : NSObject
{
blk_t blk_;
}
@end
@implementation MyObject
- (id)init
{
self = [super init];
__block id tmp = self;
blk_ = ^{
NSLog(@"self = %@", tmp);
tmp = nil;
};
return self;
}
- (void)execBlock
{
blk_();
}
- (void)dealloc
{
NSLog(@"dealloc");
}
@end
int main()
{
id object = [[MyObject alloc] init];
[object execBlock];
return 0;
}
[/code]
这个例子挺有意思的,如果执行
execBlock方法,就没有循环引用,如果不执行就有循环引用,挺值得玩味的。一方面,使用 __block 挺危险的,万一代码中不执行 block ,就造成了循环引用,而且编译器还没法检查出来;另一方面,使用 __block 可以让我们通过 __block 变量去控制对象的生命周期,而且有可能在一些非常老旧的 MRC 代码中,由于不支持 __weak,我们可以使用此方法来代替 __unsafe_unretained,从而避免悬挂指针的问题。
还有个值得一提的时,在 MRC 下,使用 __block 说明符也可以避免循环引用。因为当 block 从栈拷贝到堆时,__block 对象类型的变量不会被 retain,没有 __block 说明符的对象类型的变量则会被 retian。正是由于 __block 在 ARC 和 MRC 下的巨大差异,我们在写代码时一定要区分清楚到底是 ARC 还是 MRC。
尽管 ARC 已经如此普及,我们可能已经可以不用去管 MRC 的东西,但要有点一定要明白,ARC 和 MRC 都是基于引用计数的内存管理,其本质上是一个东西,只不过 ARC 在编译期自动化的做了内存引用计数的管理,使得系统可以在适当的时候保留内存,适当的时候释放内存。
循环引用到此为止,东西并不多。如果明白了之前的知识点,就会了解循环引用不过是前面知识点的自然延伸点罢了。
Copy 和 Release
在 ARC 下,有时需要手动拷贝和释放 block。在 MRC 下更是如此,可以直接用copy和
release来拷贝和释放
[code]void (^blk_on_heap)(void) = [blk_on_stack copy];
[blk_on_heap release];
[/code]
拷贝到堆后,就可以 用
retain持有 block
[code][blk_on_heap retain];
[/code]
然而如果 block 在栈上,使用
retain是毫无效果的,因此推荐使用
copy方法来持有 block。
block 是 C 语言的扩展,所以可以在 C 中使用 block 的语法。比如,在上面的例子中,可以直接使用
Block_copy和
Block_release函数来代替
copy和
release方法
[code]void (^blk_on_heap)(void) = Block_copy(blk_on_stack);
Block_release(blk_on_heap);
[/code]
Block_copy的作用相当于之前看到过的
_Block_copy函数,而且 Objective-C runtime 库在运行时拷贝 block 用的就是这个函数。同理,释放 block 时,runtime 调用了
Block_release函数。
最后这里有一篇总结 block 的文章的很不错,推荐大家看看:http://tanqisen.github.io/blog/2013/04/19/gcd-block-cycle-retain/
内容目录
block没那么难三block和对象的内存管理获取对象
__block 变量和对象
循环引用
Copy 和 Release
内容目录
[/i]About-Blog
1
[/i]
MicroCai 的博客
[/i]Archives
18
[/i]
* 客户端实现负载均衡
[/i]
问题记录:iOS 用户行为统计代码的剥离
[/i]
[译] 照片框架
[/i]
Autolayout 基础
[/i]
ARC 下内存泄露的那些点
[/i]
KVO 和 KVC 的使用和实现
[/i]
iOS Events and Responder Chain
[/i]
两个超大整数相加
[/i]
Effective Objective-C Notes:GCD 实现同步锁
[/i]
Effective Objective-C Notes:理解类对象
[/i]
Effective Objective-C Notes:理解消息传递机制
[/i]
Effective Objective-C Notes:Objective-C命名规范
[/i]
Effective Objective-C Notes:概览
[/i]
block没那么难(三):block和对象的内存管理
[/i]
block没那么难(二):block和变量的内存管理
[/i]
block没那么难(一):block的实现
[/i]
iOS 集合的深复制与浅复制
[/i]
[译] Block 小测验
[/i]iOS
17
[/i]
* 客户端实现负载均衡
[/i]
问题记录:iOS 用户行为统计代码的剥离
[/i]
[译] 照片框架
[/i]
Autolayout 基础
[/i]
ARC 下内存泄露的那些点
[/i]
KVO 和 KVC 的使用和实现
[/i]
iOS Events and Responder Chain
[/i]
Effective Objective-C Notes:GCD 实现同步锁
[/i]
Effective Objective-C Notes:理解类对象
[/i]
Effective Objective-C Notes:理解消息传递机制
[/i]
Effective Objective-C Notes:Objective-C命名规范
[/i]
Effective Objective-C Notes:概览
[/i]
block没那么难(三):block和对象的内存管理
[/i]
block没那么难(二):block和变量的内存管理
[/i]
block没那么难(一):block的实现
[/i]
iOS 集合的深复制与浅复制
[/i]
[译] Block 小测验
[/i]翻译
2
[/i]
[译] 照片框架
[/i]
[译] Block 小测验
[/i]计算机基础
5
[/i]
进程间通信的方式
[/i]
排序算法整理
[/i]
算法的时间复杂度
[/i]
HTTP 请求基础
[/i]
RESTful 与 HTTP
[/i]趣味题
1
[/i]
两个超大整数相加
[/i]
[/i]
以下【标签】将用于标记这篇文稿:
[/i]下载客户端
[/i]关注开发者
[/i]报告问题,建议
[/i]联系我们
添加新批注
在作者公开此批注前,只有你和作者可见。
保存
取消
修改
保存
取消
删除
私有
公开
删除
查看更早的 5 条回复
相关文章推荐
- block没那么难(二)
- python对文件的操作方式总结
- SP2-0734: 未知的命令开头 "imp scott/..." - 忽略了剩余的行。
- 程序优化--效率的计算
- SP2-0734: 未知的命令开头 "imp scott/..." - 忽略了剩余的行。
- JAVA中的深拷贝和浅拷贝
- UVALive 4857- Halloween Costumes
- C/C++程序员面试秘籍
- 10^n个整数(亿级)的排序 .
- Java线程池几个参数的理解
- C与C++的小知识
- EF Code First学习笔记 初识Code First C
- 安卓学习(二)
- 图像处理(二十二)贝叶斯抠图-CVPR 2001
- poj 2157 Maze (bfs)
- Zookeeper是什么?
- ios面试基础
- 安全网络通信SSL
- Android广播机制
- linux下的命令格式