轻松过面:一文全解iOS通知机制(经典收藏)

作者丨monkery

来源丨码上work(codework88)

简述

本文主要是针对iOS通知机制的全面解析,从接口到原理面面俱到。同时也解决了之前写的文章阿里、字节:一套高效的iOS面试题中关于通知的问题,相信看完此文再也不怕面试官问我任何通知相关问题了

由于苹果没有对相关源码开放,所以以GNUStep源码为基础进行研究,GNUStep虽然不是苹果官方的源码,但很具有参考意义,根据实现原理来猜测和实践,更重要的还可以学习观察者模式的架构设计

GNUStep地址:https://github.com/gnustep/libs-base

问题列表

先把之前的问题列出来,详细读完本文之后,你会找到答案

  1. 实现原理(结构设计、通知如何存储的、name&observer&SEL之间的关系等)

  2. 通知的发送时同步的,还是异步的

  3. NSNotificationCenter接受消息和发送消息是在一个线程里吗?如何异步发送消息

  4. NSNotificationQueue是异步还是同步发送?在哪个线程响应

  5. NSNotificationQueuerunloop的关系

  6. 如何保证通知接收的线程在主线程

  7. 页面销毁时不移除通知会崩溃吗

  8. 多次添加同一个通知会是什么结果?多次移除通知呢

  9. 下面的方式能接收到通知吗?为什么

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类主要负责三件事

  1. 添加通知

  2. 发送通知

  3. 移除通知

核心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主要做了两件事:

  1. 添加通知到队列

  2. 删除通知

核心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对象保存了queueblock信息,并且作为观察者注册到通知中心,等到接收通知时触发了响应方法,并在响应方法中把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结构体中核心的三个变量以及功能:wildcardnamednameless,在源码中直接用宏定义表示了:WILDCARDNAMELESSNAMED,下面逻辑会用到

建议如果看文字说明觉得复杂不好理解,就看看下节介绍的存储关系图

case1: 存在name(无论object是否存在)

  1. 注册通知,如果通知的name存在,则以name为key从named字典中取出值n(这个n其实被MapNode包装了一层,便于理解这里直接认为没有包装),这个n还是个字典,各种判空新建逻辑不讨论

  2. 然后以object为key,从字典n中取出对应的值,这个值就是Observation类型(后面简称obs)的链表,然后把刚开始创建的obs对象o存储进去

数据结构关系图

这里就回答了上述问题列表的问题1的一部分,现在梳理下存储关系


如果注册通知时传入name,那么会是一个双层的存储结构

  1. 找到NCTable中的named表,这个表存储了还有name的通知

  2. name作为key,找到value,这个value依然是一个map

  3. map的结构是以object作为key,obs对象为value,这个obs对象的结构上面已经解释,主要存储了observer & SEL

case2: 只存在object

  1. object为key,从nameless字典中取出value,此value是个obs类型的链表

  2. 把创建的obs类型的对象o存储到链表中

数据结构关系图

只存在object时存储只有一层,那就是objectobs对象之间的映射

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,在上面的关键类结构中已经介绍了它,设计思路值得学习

  1. 创建一个GSNotificationObserver类型的对象observer,并把queueblock保存下来

  2. 调用接口1进行通知的注册

  3. 接收到通知时会响应observerdidReceiveNotification:方法,然后在didReceiveNotification:中把block抛给指定的queue去执行

小结

  1. 从上述介绍可以总结,存储是以nameobject为维度的,即判定是不是同一个通知要从nameobject区分,如果他们都相同则认为是同一个通知,后面包括查找逻辑、删除逻辑都是以这两个为维度的,问题列表中的第九题也迎刃而解了

  2. 理解数据结构的设计是整个通知机制的核心,其他功能只是在此基础上扩展了一些逻辑

  3. 存储过程并没有做去重操作,这也解释了为什么同一个通知注册多次则响应多次

发送通知

源码

发送通知的核心逻辑比较简单,基本上就是查找和调用响应方法,核心函数如下

 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}

逻辑说明

其实上述代码注释说的很清晰了,主要做了三件事

  1. 通过namoe&bject查找到所有的obs对象(保存了observersel),放到数组中

  2. 通过performSelector:逐一调用sel,这是个同步操作

  3. 释放notification对象

小结

从源码逻辑可以看出发送过程的概述:从三个存储容器中:namednamelesswildcard去查找对应的obs对象,然后通过performSelector:逐一调用响应方法,这就完成了发送流程

核心点:

  1. 同步发送

  2. 遍历所有列表,即注册多次通知就会响应多次

删除通知

这里源码太长而且基本上都是查找删除逻辑,不一一列举,感兴趣的去下载源码看下吧

源码地址:https://github.com/gnustep/libs-base

要注意的点:

  1. 查找时仍然以nameobject为维度的,再加上observer做区分

  2. 因为查找时做了这个链表的遍历,所以删除时会把重复的通知全都删除掉

 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的时机来触发的

入队

下面为精简版的源码,看源码的注释,基本上能明白大致逻辑

  1. 根据coalesceMask参数判断是否合并通知

  2. 接着根据postingStyle参数,判断通知发送的时机,如果不是立即发送则把通知加入到队列中:_asapQueue_idleQueue

核心点:

  1. 队列是双向链表实现

  2. 当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}

发送通知

这里截取了发送通知的核心代码,这个发送通知逻辑如下:

  1. runloop触发某个时机,调用GSPrivateNotifyASAP()GSPrivateNotifyIdle()方法,这两个方法最终都调用了notify()方法

  2. notify()所做的事情就是调用NSNotificationCenterpostNotification:进行发送通知

 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总结如下

  1. 依赖runloop,所以如果在其他子线程使用NSNotificationQueue,需要开启runloop

  2. 最终还是通过NSNotificationCenter进行发送通知,所以这个角度讲它还是同步的

  3. 所谓异步,指的是非实时发送而是在合适的时机发送,并没有开启异步线程

主线程响应通知

异步线程发送通知则响应函数也是在异步线程,如果执行UI刷新相关的话就会出问题,那么如何保证在主线程响应通知呢?

其实也是比较常见的问题了,基本上解决方式如下几种:

  1. 使用addObserverForName: object: queue: usingBlock方法注册通知,指定在mainqueue上响应block

  2. 在主线程注册一个machPort,它是用来做线程通信的,当在异步线程收到通知,然后给machPort发送消息,这样肯定是在主线程处理的,具体用法去网上资料很多,苹果官网也有

总结

本文写的内容比较多,以GNUStep源码为基础进行研究,全面阐述了通知的存储、发送、异步发送等原理,对研究学习有很大帮助。原创不易,喜欢就点在看

近期精彩内容推荐:  

 有个程序媛上司是什么体验

 一个天才程序员的黑帮大佬人生

 200行Python代码做一个换脸程序

 在 IntelliJ IDEA 中使用 Git,太方便了!

在看点这里好文分享给更多人↓↓

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页