作者丨monkery
来源丨码上work(codework88)
简述
本文主要是针对iOS通知机制
的全面解析,从接口到原理面面俱到。同时也解决了之前写的文章
阿里、字节:一套高效的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 */45- (NSString*) name; // 通知的name6- (id) object; // 携带的对象7- (NSDictionary*) userInfo; // 配置信息89@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}1112- (void) dealloc13{14....15}16// 响应接收通知的方法,并在指定队列中执行block17- (void) didReceiveNotification: (NSNotification *)notif18{19 if (_queue != nil)20 {21 GSNotificationBlockOperation *op = [[GSNotificationBlockOperation alloc] 22 initWithNotification: notif block: _block];2324 [_queue addOperation: op];25 }26 else27 {28 CALL_BLOCK(_block, notif);29 }30}3132@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 ......1314 // 创建一个observation对象,持有观察者和SEL,下面进行的所有逻辑就是为了存储它15 o = obsNew(TABLE, selector, observer);1617/*======= case1: 如果name存在 =======*/18 if (name) {19 //-------- NAMED是个宏,表示名为named字典。以name为key,从named表中获取对应的mapTable20 n = GSIMapNodeForKey(NAMED, (GSIMapKey)(id)name);21 if (n == 0) { // 不存在,则创建 22 m = mapNew(TABLE); // 先取缓存,如果缓存没有则新建一个map23 GSIMapAddPair(NAMED, (GSIMapKey)(id)name, (GSIMapVal)(void*)m);24 ...25 }26 else { // 存在则把值取出来 赋值给m27 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];1516 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];1213 // 进行发送操作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->selector22 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} 910- (void) removeObserver: (id)observer11{12 if (observer == nil)13 return;1415 [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*)modes10{11 ......12 // 判断是否需要合并通知13 if (coalesceMask != NSNotificationNoCoalescing) {14 [self dequeueNotificationsMatching: notification15 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;2829 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 8 { 9 NSNotification *n = (NSNotification*)ptr[pos];1011 [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源码为基础进行研究,全面阐述了通知的存储、发送、异步发送等原理,对研究学习有很大帮助。原创不易,喜欢就点在看哦
近期精彩内容推荐:
有个程序媛上司是什么体验
一个天才程序员的黑帮大佬人生
200行Python代码做一个换脸程序
在 IntelliJ IDEA 中使用 Git,太方便了!
在看点这里好文分享给更多人↓↓