轻松过面:一文全解iOS通知机制(经典收藏)
共 21055字,需浏览 43分钟
·
2021-06-15 10:01
作者丨monkery
来源丨码上work(codework88)
简述
本文主要是针对iOS通知机制
的全面解析,从接口到原理面面俱到。相信看完此文再也不怕面试官问我任何通知相关问题了
由于苹果没有对相关源码开放,所以以GNUStep源码为基础进行研究,GNUStep虽然不是苹果官方的源码,但很具有参考意义,根据实现原理来猜测和实践,更重要的还可以学习观察者模式的架构设计
GNUStep地址:https://github.com/gnustep/libs-base
问题列表
先把之前的问题列出来,详细读完本文之后,你会找到答案
实现原理(结构设计、通知如何存储的、
name&observer&SEL
之间的关系等)通知的发送时同步的,还是异步的
NSNotificationCenter
接受消息和发送消息是在一个线程里吗?如何异步发送消息NSNotificationQueue
是异步还是同步发送?在哪个线程响应NSNotificationQueue
和runloop
的关系如何保证通知接收的线程在主线程
页面销毁时不移除通知会崩溃吗
多次添加同一个通知会是什么结果?多次移除通知呢
下面的方式能接收到通知吗?为什么
1// 发送通知
2[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleNotification:) name:@"TestNotification" object:@1];
3// 接收通知
4[NSNotificationCenter.defaultCenter postNotificationName:@"TestNotification" object:nil];
关键类结构
NSNotification
用于描述通知的类,一个NSNotification
对象就包含了一条通知的信息,所以当创建一个通知时通常包含如下属性:
1@interface NSNotification : NSObject <NSCopying, NSCoding>
2...
3/* Querying a Notification Object */
4
5- (NSString*) name; // 通知的name
6- (id) object; // 携带的对象
7- (NSDictionary*) userInfo; // 配置信息
8
9@end
一般用于发送通知时使用,常用api如下:
1- (void)postNotification:(NSNotification *)notification;
NSNotificationCenter
这是个单例类,负责管理通知的创建和发送,属于最核心的类了。而NSNotificationCenter
类主要负责三件事
添加通知
发送通知
移除通知
核心API
如下:
1// 添加通知
2- (void)addObserver:(id)observer selector:(SEL)aSelector name:(nullable NSNotificationName)aName object:(nullable id)anObject;
3// 发送通知
4- (void)postNotification:(NSNotification *)notification;
5- (void)postNotificationName:(NSNotificationName)aName object:(nullable id)anObject;
6- (void)postNotificationName:(NSNotificationName)aName object:(nullable id)anObject userInfo:(nullable NSDictionary *)aUserInfo;
7// 删除通知
8- (void)removeObserver:(id)observer;
NSNotificationQueue
功能介绍
通知队列,用于异步发送消息,这个异步并不是开启线程,而是把通知存到双向链表实现的队列里面,等待某个时机触发时调用NSNotificationCenter
的发送接口进行发送通知,这么看NSNotificationQueue
最终还是调用NSNotificationCenter
进行消息的分发
另外NSNotificationQueue
是依赖runloop
的,所以如果线程的runloop
未开启则无效,至于为什么依赖runloop
下面会解释
NSNotificationQueue
主要做了两件事:
添加通知到队列
删除通知
核心API
如下:
1// 把通知添加到队列中,NSPostingStyle是个枚举,下面会介绍
2- (void)enqueueNotification:(NSNotification *)notification postingStyle:(NSPostingStyle)postingStyle;
3// 删除通知,把满足合并条件的通知从队列中删除
4- (void)dequeueNotificationsMatching:(NSNotification *)notification coalesceMask:(NSUInteger)coalesceMask;
队列的合并策略和发送时机
把通知添加到队列等待发送,同时提供了一些附加条件供开发者选择,如:什么时候发送通知、如何合并通知等,系统给了如下定义
1// 表示通知的发送时机
2typedef NS_ENUM(NSUInteger, NSPostingStyle) {
3 NSPostWhenIdle = 1, // runloop空闲时发送通知
4 NSPostASAP = 2, // 尽快发送,这种情况稍微复杂,这种时机是穿插在每次事件完成期间来做的
5 NSPostNow = 3 // 立刻发送或者合并通知完成之后发送
6};
7// 通知合并的策略,有些时候同名通知只想存在一个,这时候就可以用到它了
8typedef NS_OPTIONS(NSUInteger, NSNotificationCoalescing) {
9 NSNotificationNoCoalescing = 0, // 默认不合并
10 NSNotificationCoalescingOnName = 1, // 只要name相同,就认为是相同通知
11 NSNotificationCoalescingOnSender = 2 // object相同
12};
GSNotificationObserver
这个类是GNUStep源码中定义的,它的作用是代理观察者,主要用来实现接口:addObserverForName:object: queue: usingBlock:
时用到,即要实现在指定队列回调block,那么GSNotificationObserver
对象保存了queue
和block
信息,并且作为观察者注册到通知中心,等到接收通知时触发了响应方法,并在响应方法中把block
抛到指定queue
中执行,定义如下:
1@implementation GSNotificationObserver
2{
3 NSOperationQueue *_queue; // 保存传入的队列
4 GSNotificationBlock _block; // 保存传入的block
5}
6- (id) initWithQueue: (NSOperationQueue *)queue
7 block: (GSNotificationBlock)block
8{
9......初始化操作
10}
11
12- (void) dealloc
13{
14....
15}
16// 响应接收通知的方法,并在指定队列中执行block
17- (void) didReceiveNotification: (NSNotification *)notif
18{
19 if (_queue != nil)
20 {
21 GSNotificationBlockOperation *op = [[GSNotificationBlockOperation alloc]
22 initWithNotification: notif block: _block];
23
24 [_queue addOperation: op];
25 }
26 else
27 {
28 CALL_BLOCK(_block, notif);
29 }
30}
31
32@end
存储容器
上面介绍了一些类的功能,但是要想实现通知中心的逻辑必须设计一套合理的存储结构,对于通知的存储基本上围绕下面几个结构体来做(大致了解下,后面章节会用到),后面会详细介绍具体逻辑的
1// 根容器,NSNotificationCenter持有
2typedef struct NCTbl {
3 Observation *wildcard; /* 链表结构,保存既没有name也没有object的通知 */
4 GSIMapTable nameless; /* 存储没有name但是有object的通知 */
5 GSIMapTable named; /* 存储带有name的通知,不管有没有object */
6 ...
7} NCTable;
8
9// Observation 存储观察者和响应结构体,基本的存储单元
10typedef struct Obs {
11 id observer; /* 观察者,接收通知的对象 */
12 SEL selector; /* 响应方法 */
13 struct Obs *next; /* Next item in linked list. */
14 ...
15} Observation;
注册通知
正式开始“注册通知”的深入研究,注册通知有几个常用方法,但只需要研究典型的一两个就够了,原理都是一样的
目前只介绍NSNotificationCenter
的注册流程,NSNotificationQueue
的方式在下面章节单独拎出来解释
接口1
直接看源码(精简版便于理解)
1/*
2observer:观察者,即通知的接收者
3selector:接收到通知时的响应方法
4name: 通知name
5object:携带对象
6*/
7- (void) addObserver: (id)observer
8 selector: (SEL)selector
9 name: (NSString*)name
10 object: (id)object {
11 // 前置条件判断
12 ......
13
14 // 创建一个observation对象,持有观察者和SEL,下面进行的所有逻辑就是为了存储它
15 o = obsNew(TABLE, selector, observer);
16
17/*======= case1: 如果name存在 =======*/
18 if (name) {
19 //-------- NAMED是个宏,表示名为named字典。以name为key,从named表中获取对应的mapTable
20 n = GSIMapNodeForKey(NAMED, (GSIMapKey)(id)name);
21 if (n == 0) { // 不存在,则创建
22 m = mapNew(TABLE); // 先取缓存,如果缓存没有则新建一个map
23 GSIMapAddPair(NAMED, (GSIMapKey)(id)name, (GSIMapVal)(void*)m);
24 ...
25 }
26 else { // 存在则把值取出来 赋值给m
27 m = (GSIMapTable)n->value.ptr;
28 }
29 //-------- 以object为key,从字典m中取出对应的value,其实value被MapNode的结构包装了一层,这里不追究细节
30 n = GSIMapNodeForSimpleKey(m, (GSIMapKey)object);
31 if (n == 0) {// 不存在,则创建
32 o->next = ENDOBS;
33 GSIMapAddPair(m, (GSIMapKey)object, (GSIMapVal)o);
34 }
35 else {
36 list = (Observation*)n->value.ptr;
37 o->next = list->next;
38 list->next = o;
39 }
40 }
41/*======= case2:如果name为空,但object不为空 =======*/
42 else if (object) {
43 // 以object为key,从nameless字典中取出对应的value,value是个链表结构
44 n = GSIMapNodeForSimpleKey(NAMELESS, (GSIMapKey)object);
45 // 不存在则新建链表,并存到map中
46 if (n == 0) {
47 o->next = ENDOBS;
48 GSIMapAddPair(NAMELESS, (GSIMapKey)object, (GSIMapVal)o);
49 }
50 else { // 存在 则把值接到链表的节点上
51 ...
52 }
53 }
54/*======= case3:name 和 object 都为空 则存储到wildcard链表中 =======*/
55 else {
56 o->next = WILDCARD;
57 WILDCARD = o;
58 }
59}
逻辑说明
从上面介绍的存储容器中我们了解到NCTable
结构体中核心的三个变量以及功能:wildcard
、named
、nameless
,在源码中直接用宏定义表示了:WILDCARD
、NAMELESS
、NAMED
,下面逻辑会用到
建议如果看文字说明觉得复杂不好理解,就看看下节介绍的存储关系图
case1: 存在name(无论object是否存在)
注册通知,如果通知的
name
存在,则以name
为key从named
字典中取出值n
(这个n
其实被MapNode
包装了一层,便于理解这里直接认为没有包装),这个n
还是个字典,各种判空新建逻辑不讨论然后以
object
为key,从字典n
中取出对应的值,这个值就是Observation
类型(后面简称obs
)的链表,然后把刚开始创建的obs
对象o
存储进去
数据结构关系图
这里就回答了上述问题列表的问题1的一部分,现在梳理下存储关系
如果注册通知时传入
name
,那么会是一个双层的存储结构
找到
NCTable
中的named
表,这个表存储了还有name
的通知以
name
作为key,找到value
,这个value
依然是一个map
map
的结构是以object
作为key,obs
对象为value,这个obs
对象的结构上面已经解释,主要存储了observer & SEL
case2: 只存在object
以
object
为key,从nameless
字典中取出value,此value是个obs
类型的链表把创建的
obs
类型的对象o
存储到链表中
数据结构关系图
只存在object
时存储只有一层,那就是object
和obs
对象之间的映射
case3: 没有name和object
这种情况直接把obs
对象存放在了Observation *wildcard
链表结构中
接口2
接口功能: 此接口实现的功能是在接收到通知时,在指定队列queue
执行block
源码
1// 这个api使用频率较低,怎么实现在指定队列回调block的,值得研究
2- (id) addObserverForName: (NSString *)name
3 object: (id)object
4 queue: (NSOperationQueue *)queue
5 usingBlock: (GSNotificationBlock)block
6{
7 // 创建一个临时观察者
8 GSNotificationObserver *observer =
9 [[GSNotificationObserver alloc] initWithQueue: queue block: block];
10 // 调用了接口1的注册方法
11 [self addObserver: observer
12 selector: @selector(didReceiveNotification:)
13 name: name
14 object: object];
15
16 return observer;
17}
逻辑说明
这个接口依赖于接口1
,只是多了一层代理观察者GSNotificationObserver
,在上面的关键类结构中已经介绍了它,设计思路值得学习
创建一个
GSNotificationObserver
类型的对象observer
,并把queue
和block
保存下来调用接口1进行通知的注册
接收到通知时会响应
observer
的didReceiveNotification:
方法,然后在didReceiveNotification:
中把block
抛给指定的queue
去执行
小结
从上述介绍可以总结,存储是以
name
和object
为维度的,即判定是不是同一个通知要从name
和object
区分,如果他们都相同则认为是同一个通知,后面包括查找逻辑、删除逻辑都是以这两个为维度的,问题列表中的第九题也迎刃而解了理解数据结构的设计是整个通知机制的核心,其他功能只是在此基础上扩展了一些逻辑
存储过程并没有做去重操作,这也解释了为什么同一个通知注册多次则响应多次
发送通知
源码
发送通知的核心逻辑比较简单,基本上就是查找和调用响应方法,核心函数如下
1// 发送通知
2- (void) postNotificationName: (NSString*)name
3 object: (id)object
4 userInfo: (NSDictionary*)info
5{
6// 构造一个GSNotification对象, GSNotification继承了NSNotification
7 GSNotification *notification;
8 notification = (id)NSAllocateObject(concrete, 0, NSDefaultMallocZone());
9 notification->_name = [name copyWithZone: [self zone]];
10 notification->_object = [object retain];
11 notification->_info = [info retain];
12
13 // 进行发送操作
14 [self _postAndRelease: notification];
15}
16//发送通知的核心函数,主要做了三件事:查找通知、发送、释放资源
17- (void) _postAndRelease: (NSNotification*)notification {
18 //step1: 从named、nameless、wildcard表中查找对应的通知
19 ...
20 //step2:执行发送,即调用performSelector执行响应方法,从这里可以看出是同步的
21 [o->observer performSelector: o->selector
22 withObject: notification];
23 //step3: 释放资源
24 RELEASE(notification);
25}
逻辑说明
其实上述代码注释说的很清晰了,主要做了三件事
通过
namoe&bject
查找到所有的obs
对象(保存了observer
和sel
),放到数组中通过
performSelector:
逐一调用sel
,这是个同步操作释放
notification
对象
小结
从源码逻辑可以看出发送过程的概述:从三个存储容器中:named
、nameless
、wildcard
去查找对应的obs
对象,然后通过performSelector:
逐一调用响应方法,这就完成了发送流程
核心点:
同步发送
遍历所有列表,即注册多次通知就会响应多次
删除通知
这里源码太长而且基本上都是查找删除逻辑,不一一列举,感兴趣的去下载源码看下吧
源码地址:https://github.com/gnustep/libs-base
要注意的点:
查找时仍然以
name
和object
为维度的,再加上observer
做区分因为查找时做了这个链表的遍历,所以删除时会把重复的通知全都删除掉
1// 删除已经注册的通知
2- (void) removeObserver: (id)observer
3 name: (NSString*)name
4 object: (id)object {
5 if (name == nil && object == nil && observer == nil)
6 return;
7 ...
8}
9
10- (void) removeObserver: (id)observer
11{
12 if (observer == nil)
13 return;
14
15 [self removeObserver: observer name: nil object: nil];
16}
异步通知
上面介绍的NSNotificationCenter
都是同步发送的,而这里介绍关于NSNotificationQueue
的异步发送,从线程的角度看并不是真正的异步发送,或可称为延时发送,它是利用了runloop
的时机来触发的
入队
下面为精简版的源码,看源码的注释,基本上能明白大致逻辑
根据
coalesceMask
参数判断是否合并通知接着根据
postingStyle
参数,判断通知发送的时机,如果不是立即发送则把通知加入到队列中:_asapQueue
、_idleQueue
核心点:
队列是双向链表实现
当postingStyle值是立即发送时,调用的是
NSNotificationCenter
进行发送的,所以NSNotificationQueue
还是依赖NSNotificationCenter
进行发送
1/*
2* 把要发送的通知添加到队列,等待发送
3* NSPostingStyle 和 coalesceMask在上面的类结构中有介绍
4* modes这个就和runloop有关了,指的是runloop的mode
5*/
6- (void) enqueueNotification: (NSNotification*)notification
7 postingStyle: (NSPostingStyle)postingStyle
8 coalesceMask: (NSUInteger)coalesceMask
9 forModes: (NSArray*)modes
10{
11 ......
12 // 判断是否需要合并通知
13 if (coalesceMask != NSNotificationNoCoalescing) {
14 [self dequeueNotificationsMatching: notification
15 coalesceMask: coalesceMask];
16 }
17 switch (postingStyle) {
18 case NSPostNow: {
19 ...
20 // 如果是立马发送,则调用NSNotificationCenter进行发送
21 [_center postNotification: notification];
22 break;
23 }
24 case NSPostASAP:
25 // 添加到_asapQueue队列,等待发送
26 add_to_queue(_asapQueue, notification, modes, _zone);
27 break;
28
29 case NSPostWhenIdle:
30 // 添加到_idleQueue队列,等待发送
31 add_to_queue(_idleQueue, notification, modes, _zone);
32 break;
33 }
34}
发送通知
这里截取了发送通知的核心代码,这个发送通知逻辑如下:
runloop
触发某个时机,调用GSPrivateNotifyASAP()
和GSPrivateNotifyIdle()
方法,这两个方法最终都调用了notify()
方法notify()
所做的事情就是调用NSNotificationCenter
的postNotification:
进行发送通知
1static void notify(NSNotificationCenter *center,
2 NSNotificationQueueList *list,
3 NSString *mode, NSZone *zone)
4{
5 ......
6 // 循环遍历发送通知
7 for (pos = 0; pos < len; pos++)
8 {
9 NSNotification *n = (NSNotification*)ptr[pos];
10
11 [center postNotification: n];
12 RELEASE(n);
13 }
14 ......
15}
16// 发送_asapQueue中的通知
17void GSPrivateNotifyASAP(NSString *mode)
18{
19 notify(item->queue->_center,
20 item->queue->_asapQueue,
21 mode,
22 item->queue->_zone);
23}
24// 发送_idleQueue中的通知
25void GSPrivateNotifyIdle(NSString *mode)
26{
27 notify(item->queue->_center,
28 item->queue->_idleQueue,
29 mode,
30 item->queue->_zone);
31}
小结
对于NSNotificationQueue
总结如下
依赖
runloop
,所以如果在其他子线程使用NSNotificationQueue
,需要开启runloop最终还是通过
NSNotificationCenter
进行发送通知,所以这个角度讲它还是同步的所谓异步,指的是非实时发送而是在合适的时机发送,并没有开启异步线程
主线程响应通知
异步线程发送通知则响应函数也是在异步线程,如果执行UI刷新相关的话就会出问题,那么如何保证在主线程响应通知呢?
其实也是比较常见的问题了,基本上解决方式如下几种:
使用
addObserverForName: object: queue: usingBlock
方法注册通知,指定在mainqueue
上响应block
在主线程注册一个
machPort
,它是用来做线程通信的,当在异步线程收到通知,然后给machPort
发送消息,这样肯定是在主线程处理的,具体用法去网上资料很多,苹果官网也有
总结
本文写的内容比较多,以GNUStep源码为基础进行研究,全面阐述了通知的存储、发送、异步发送等原理,对研究学习有很大帮助。原创不易,喜欢就点在看哦
-End-
最近有一些小伙伴,让我帮忙找一些 面试题 资料,于是我翻遍了收藏的 5T 资料后,汇总整理出来,可以说是程序员面试必备!所有资料都整理到网盘了,欢迎下载!
面试题
】即可获取