本文主要是针对iOS通知机制的全面解析，从接口到原理面面俱到。同时也解决了之前写的文章阿里、字节：一套高效的iOS面试题中关于通知的问题，相信看完此文再也不怕面试官问我任何通知相关问题了
由于苹果没有对相关源码开放，所以以GNUStep源码为基础进行研究，GNUStep虽然不是苹果官方的源码，但很具有参考意义，根据实现原理来猜测和实践，更重要的还可以学习观察者模式的架构设计

问题列表

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

  • 实现原理（结构设计、通知如何存储的、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];
    作为一个开发者，有一个学习的氛围跟一个交流圈子特别重要，这是一个我的iOS交流群：1012951431 不管你是小白还是大牛欢迎入驻 ，分享BAT,阿里面试题、面试经验，讨论技术， 大家一起交流学习成长！
    另附上一份各好友收集的大厂面试题，进群可自行下载！
    轻松过面：一文全解iOS通知机制(经典收藏) - 图1

    关键类结构

    NSNotification

    用于描述通知的类，一个NSNotification对象就包含了一条通知的信息，所以当创建一个通知时通常包含如下属性： ``` @interface NSNotification : NSObject … / Querying a Notification Object /
  • (NSString*) name; // 通知的name
  • (id) object; // 携带的对象
  • (NSDictionary*) userInfo; // 配置信息 @end 一般用于发送通知时使用，常用api如下：c
  • (void)postNotification:(NSNotification *)notification; ```

    NSNotificationCenter

    这是个单例类，负责管理通知的创建和发送，属于最核心的类了。而NSNotificationCenter类主要负责三件事
    1. 添加通知
    1. 发送通知
    1. 移除通知
    核心API如下： ```cpp // 添加通知
  • (void)addObserver:(id)observer selector:(SEL)aSelector name:(nullable NSNotificationName)aName object:(nullable id)anObject; // 发送通知
  • (void)postNotification:(NSNotification *)notification;
  • (void)postNotificationName:(NSNotificationName)aName object:(nullable id)anObject;
  • (void)postNotificationName:(NSNotificationName)aName object:(nullable id)anObject userInfo:(nullable NSDictionary *)aUserInfo; // 删除通知
  • (void)removeObserver:(id)observer; ```

    NSNotificationQueue

    功能介绍

    通知队列，用于异步发送消息，这个异步并不是开启线程，而是把通知存到双向链表实现的队列里面，等待某个时机触发时调用NSNotificationCenter的发送接口进行发送通知，这么看NSNotificationQueue最终还是调用NSNotificationCenter进行消息的分发
    另外NSNotificationQueue是依赖runloop的，所以如果线程的runloop未开启则无效，至于为什么依赖runloop下面会解释
    NSNotificationQueue主要做了两件事：
    1. 添加通知到队列
    2. 删除通知
    核心API如下： ```cpp // 把通知添加到队列中，NSPostingStyle是个枚举，下面会介绍
  • (void)enqueueNotification:(NSNotification *)notification postingStyle:(NSPostingStyle)postingStyle; // 删除通知，把满足合并条件的通知从队列中删除
  • (void)dequeueNotificationsMatching:(NSNotification *)notification coalesceMask:(NSUInteger)coalesceMask;
    1. <a name="G70N1"></a>
    2. ### 队列的合并策略和发送时机
    3. 把通知添加到队列等待发送，同时提供了一些附加条件供开发者选择，如：什么时候发送通知、如何合并通知等，系统给了如下定义
    4. ```cpp
    5. // 表示通知的发送时机
    6. typedef NS_ENUM(NSUInteger, NSPostingStyle) {
    7.   NSPostWhenIdle = 1, // runloop空闲时发送通知
    8.   NSPostASAP = 2, // 尽快发送，这种情况稍微复杂，这种时机是穿插在每次事件完成期间来做的
    9.   NSPostNow = 3 // 立刻发送或者合并通知完成之后发送
    10. };
    11. // 通知合并的策略，有些时候同名通知只想存在一个，这时候就可以用到它了
    12. typedef NS_OPTIONS(NSUInteger, NSNotificationCoalescing) {
    13.   NSNotificationNoCoalescing = 0, // 默认不合并
    14.   NSNotificationCoalescingOnName = 1, // 只要name相同，就认为是相同通知
    15.   NSNotificationCoalescingOnSender = 2  // object相同
    16. };

    GSNotificationObserver

    这个类是GNUStep源码中定义的，它的作用是代理观察者，主要用来实现接口：addObserverForName：object: queue: usingBlock:时用到，即要实现在指定队列回调block，那么GSNotificationObserver对象保存了queue和block信息，并且作为观察者注册到通知中心，等到接收通知时触发了响应方法，并在响应方法中把block抛到指定queue中执行，定义如下： ```cpp @implementation GSNotificationObserver { NSOperationQueue *_queue; // 保存传入的队列 GSNotificationBlock _block; // 保存传入的block }
  • (id) initWithQueue: (NSOperationQueue *)queue 
    1.          block: (GSNotificationBlock)block
    { ……初始化操作 }
  • (void) dealloc { …. } // 响应接收通知的方法，并在指定队列中执行block
  • (void) didReceiveNotification: (NSNotification *)notif { if (_queue != nil) {
    1.   GSNotificationBlockOperation *op = [[GSNotificationBlockOperation alloc] 
    2.       initWithNotification: notif block: _block];
    3.   [_queue addOperation: op];
    } else {
    1.   CALL_BLOCK(_block, notif);
    } } @end ```

    存储容器

    上面介绍了一些类的功能，但是要想实现通知中心的逻辑必须设计一套合理的存储结构，对于通知的存储基本上围绕下面几个结构体来做（大致了解下，后面章节会用到），后面会详细介绍具体逻辑的
  1. // 根容器，NSNotificationCenter持有
  2. typedef struct NCTbl {
  3.   Observation       *wildcard;  /* 链表结构，保存既没有name也没有object的通知 */
  4.   GSIMapTable       nameless;   /* 存储没有name但是有object的通知 */
  5.   GSIMapTable       named;      /* 存储带有name的通知，不管有没有object  */
  6.     ...
  7. } NCTable;
  8. // Observation 存储观察者和响应结构体，基本的存储单元
  9. typedef struct  Obs {
  10.   id        observer;   /* 观察者，接收通知的对象  */
  11.   SEL       selector;   /* 响应方法     */
  12.   struct Obs    *next;      /* Next item in linked list.    */
  13.   ...
  14. } Observation;

注册通知

正式开始“注册通知”的深入研究，注册通知有几个常用方法，但只需要研究典型的一两个就够了，原理都是一样的
目前只介绍NSNotificationCenter的注册流程，NSNotificationQueue的方式在下面章节单独拎出来解释

接口1

直接看源码（精简版便于理解）

  1. /*
  2. observer：观察者，即通知的接收者
  3. selector：接收到通知时的响应方法
  4. name: 通知name
  5. object：携带对象
  6. */
  7. - (void) addObserver: (id)observer
  8.             selector: (SEL)selector
  9.                 name: (NSString*)name 
  10.                 object: (id)object {
  11.   // 前置条件判断
  12.   ......
  13.   // 创建一个observation对象，持有观察者和SEL，下面进行的所有逻辑就是为了存储它
  14.   o = obsNew(TABLE, selector, observer);
  15. /*======= case1： 如果name存在 =======*/
  16.   if (name) {
  17.     //-------- NAMED是个宏，表示名为named字典。以name为key，从named表中获取对应的mapTable
  18.       n = GSIMapNodeForKey(NAMED, (GSIMapKey)(id)name);
  19.       if (n == 0) { // 不存在，则创建 
  20.           m = mapNew(TABLE); // 先取缓存，如果缓存没有则新建一个map
  21.           GSIMapAddPair(NAMED, (GSIMapKey)(id)name, (GSIMapVal)(void*)m);
  22.           ...
  23.       }
  24.       else { // 存在则把值取出来 赋值给m
  25.           m = (GSIMapTable)n->value.ptr;
  26.       }
  27.     //-------- 以object为key，从字典m中取出对应的value，其实value被MapNode的结构包装了一层，这里不追究细节
  28.       n = GSIMapNodeForSimpleKey(m, (GSIMapKey)object);
  29.       if (n == 0) {// 不存在，则创建 
  30.           o->next = ENDOBS;
  31.           GSIMapAddPair(m, (GSIMapKey)object, (GSIMapVal)o);
  32.       }
  33.       else {
  34.           list = (Observation*)n->value.ptr;
  35.           o->next = list->next;
  36.           list->next = o;
  37.       }
  38.     }
  39. /*======= case2：如果name为空，但object不为空 =======*/
  40.   else if (object) {
  41.     // 以object为key，从nameless字典中取出对应的value，value是个链表结构
  42.       n = GSIMapNodeForSimpleKey(NAMELESS, (GSIMapKey)object);
  43.       // 不存在则新建链表，并存到map中
  44.       if (n == 0) { 
  45.           o->next = ENDOBS;
  46.           GSIMapAddPair(NAMELESS, (GSIMapKey)object, (GSIMapVal)o);
  47.       }
  48.       else { // 存在 则把值接到链表的节点上
  49.         ...
  50.       }
  51.     }
  52. /*======= case3：name 和 object 都为空 则存储到wildcard链表中 =======*/
  53.   else {
  54.       o->next = WILDCARD;
  55.       WILDCARD = o;
  56.   }
  57. }

逻辑说明

从上面介绍的存储容器中我们了解到NCTable结构体中核心的三个变量以及功能：wildcard、named、nameless，在源码中直接用宏定义表示了：WILDCARD、NAMELESS、NAMED，下面逻辑会用到
建议如果看文字说明觉得复杂不好理解，就看看下节介绍的存储关系图
case1: 存在name（无论object是否存在）

  1. 注册通知，如果通知的name存在，则以name为key从named字典中取出值n(这个n其实被MapNode包装了一层，便于理解这里直接认为没有包装)，这个n还是个字典，各种判空新建逻辑不讨论
    1. 然后以object为key，从字典n中取出对应的值，这个值就是Observation类型(后面简称obs)的链表，然后把刚开始创建的obs对象o存储进去

数据结构关系图
这里就回答了上述问题列表的问题1的一部分，现在梳理下存储关系
轻松过面：一文全解iOS通知机制(经典收藏) - 图2
如果注册通知时传入name，那么会是一个双层的存储结构

  1. 找到NCTable中的named表，这个表存储了还有name的通知
    1. 以name作为key，找到value，这个value依然是一个map
    map的结构是以object作为key，obs对象为value，这个obs对象的结构上面已经解释，主要存储了observer & SEL

case2: 只存在object

  1. 以object为key，从nameless字典中取出value，此value是个obs类型的链表
    1. 把创建的obs类型的对象o存储到链表中
    数据结构关系图
    轻松过面：一文全解iOS通知机制(经典收藏) - 图3
    只存在object时存储只有一层，那就是object和obs对象之间的映射
    case3: 没有name和object
    这种情况直接把obs对象存放在了Observation *wildcard 链表结构中

    接口2

    源码

    接口功能： 此接口实现的功能是在接收到通知时，在指定队列queue执行block ``` // 这个api使用频率较低，怎么实现在指定队列回调block的，值得研究
  • (id) addObserverForName: (NSString *)name 
    1.              object: (id)object 
    2.               queue: (NSOperationQueue *)queue 
    3.          usingBlock: (GSNotificationBlock)block
    { // 创建一个临时观察者 GSNotificationObserver *observer = 
    1.   [[GSNotificationObserver alloc] initWithQueue: queue block: block];
    // 调用了接口1的注册方法 [self addObserver: observer 
    1.        selector: @selector(didReceiveNotification:) 
    2.            name: name 
    3.          object: object];
    return observer; } ```

    逻辑说明

    这个接口依赖于接口1，只是多了一层代理观察者GSNotificationObserver，在关键类结构中已经介绍了它，设计思路值得学习
  1. 创建一个GSNotificationObserver类型的对象observer，并把queue和block保存下来
    1. 调用接口1进行通知的注册
    1. 接收到通知时会响应observer的didReceiveNotification:方法，然后在didReceiveNotification:中把block抛给指定的queue去执行

小结

  1. 从上述介绍可以总结，存储是以name和object为维度的，即判定是不是同一个通知要从name和object区分，如果他们都相同则认为是同一个通知，后面包括查找逻辑、删除逻辑都是以这两个为维度的，问题列表中的第九题也迎刃而解了
    1. 理解数据结构的设计是整个通知机制的核心，其他功能只是在此基础上扩展了一些逻辑
    1. 存储过程并没有做去重操作，这也解释了为什么同一个通知注册多次则响应多次

    发送通知

    源码

    发送通知的核心逻辑比较简单，基本上就是查找和调用响应方法，核心函数如下
  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.   [self _postAndRelease: notification];
  14. }
  15. //发送通知的核心函数，主要做了三件事：查找通知、发送、释放资源
  16. - (void) _postAndRelease: (NSNotification*)notification {
  17.     //step1: 从named、nameless、wildcard表中查找对应的通知
  18.     ...
  19.     //step2：执行发送，即调用performSelector执行响应方法，从这里可以看出是同步的
  20.     [o->observer performSelector: o->selector
  21.                     withObject: notification];
  22.     //step3: 释放资源
  23.     RELEASE(notification);
  24. }

逻辑说明

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

  1. 通过name & object 查找到所有的obs对象(保存了observer和sel)，放到数组中
    1. 通过performSelector：逐一调用sel，这是个同步操作
    1. 释放notification对象

小结

从源码逻辑可以看出发送过程的概述：从三个存储容器中：named、nameless、wildcard去查找对应的obs对象，然后通过performSelector：逐一调用响应方法，这就完成了发送流程
核心点：

  1. 同步发送
    1. 遍历所有列表，即注册多次通知就会响应多次

删除通知

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

  1. 查找时仍然以name和object为维度的，再加上observer做区分
    1. 因为查找时做了这个链表的遍历，所以删除时会把重复的通知全都删除掉
  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. - (void) removeObserver: (id)observer
  10. {
  11.   if (observer == nil)
  12.     return;
  13.   [self removeObserver: observer name: nil object: nil];
  14. }

异步通知

上面介绍的NSNotificationCenter都是同步发送的，而这里介绍关于NSNotificationQueue的异步发送，从线程的角度看并不是真正的异步发送，或可称为延时发送，它是利用了runloop的时机来触发的

入队

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

  1. 根据coalesceMask参数判断是否合并通知
    1. 接着根据postingStyle参数，判断通知发送的时机，如果不是立即发送则把通知加入到队列中：_asapQueue、_idleQueue

核心点：

  1. 队列是双向链表实现
    1. 当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.       case NSPostWhenIdle:
  29.         // 添加到_idleQueue队列，等待发送
  30.         add_to_queue(_idleQueue, notification, modes, _zone);
  31.         break;
  32.     }
  33. }

发送通知

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

runloop触发某个时机，调用GSPrivateNotifyASAP()和GSPrivateNotifyIdle()方法，这两个方法最终都调用了notify()方法
notify()所做的事情就是调用NSNotificationCenter的postNotification:进行发送通知

  1. static 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.       [center postNotification: n];
  11.       RELEASE(n);
  12.     }
  13.     ......  
  14. }
  15. // 发送_asapQueue中的通知
  16. void GSPrivateNotifyASAP(NSString *mode)
  17. {
  18.     notify(item->queue->_center,
  19.         item->queue->_asapQueue,
  20.         mode,
  21.         item->queue->_zone);
  22. }
  23. // 发送_idleQueue中的通知
  24. void GSPrivateNotifyIdle(NSString *mode)
  25. {
  26.     notify(item->queue->_center,
  27.         item->queue->_idleQueue,
  28.         mode,
  29.         item->queue->_zone);
  30. }

小结

对于NSNotificationQueue总结如下

  1. 依赖runloop，所以如果在其他子线程使用NSNotificationQueue，需要开启runloop
    1. 最终还是通过NSNotificationCenter进行发送通知，所以这个角度讲它还是同步的
    1. 所谓异步，指的是非实时发送而是在合适的时机发送，并没有开启异步线程

主线程响应通知

异步线程发送通知则响应函数也是在异步线程，如果执行UI刷新相关的话就会出问题，那么如何保证在主线程响应通知呢？
其实也是比较常见的问题了，基本上解决方式如下几种：

  1. 使用addObserverForName: object: queue: usingBlock方法注册通知，指定在mainqueue上响应block
    1. 在主线程注册一个machPort，它是用来做线程通信的，当在异步线程收到通知，然后给machPort发送消息，这样肯定是在主线程处理的，具体用法去网上资料很多，苹果官网也有

总结

本文写的内容比较多，以GNUStep源码为基础进行研究，全面阐述了通知的存储、发送、异步发送等原理，对研究学习有很大帮助
另外，如果你想一起进阶，不妨添加一下交流群1012951431，选择加入一起交流，一起学习。期待你的加入！