开发前端软件素材源码教程下载网站

全部
网站模板
网页特效
网站源码
素材资源
建站学院
软件工具
mysql mysql 微信 微信 小程序 苹果 dedecms 修真图
当前位置：首页 > 建站学院 > 其他教程 >  NotificationCenter类的实现原理是什么

NotificationCenter类的实现原理是什么

其他教程   发布日期：2024年10月31日   浏览次数：253次

这篇文章主要讲解了“NotificationCenter类的实现原理是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“NotificationCenter类的实现原理是什么”吧！

正文

NotificationCenter是一个系统组件，它负责协调和管理事件的通知和响应。它的基本原理是基于观察者模式！而 Apple 对其是闭源的，因此无法查看 NotificationCenter 的源码，但是可以通过分析开源的 Swift 来理解 NotificationCenter 的实现，以下是一个简化的实现：

简单实现

1、首先定义一个NotificationCenter类定义

  1. class RYNotificationCenter {
  2.     private init(){}
  3.     static let `default` = RYNotificationCenter()
  4.     private var observers: [RYNotificationObserver] = []
  5. }

定义了一个单例，用于在整个程序中共享，

  1. observers
数组用来存储已经注册的所有观察者。

2、然后定义一个观察者对象

观察者对象用来封装具体的观察者的信息。

  1. class RYNotificationObserver {
  2.     var name: String
  3.     var block: (Notification) -> Void
  4.     init(name: String, block: @escaping (Notification) -> Void) {
  5.         self.name = name
  6.         self.block = block
  7.     }
  8. }

3、在NotificationCenter中添加注册观察者的方法

  1. func addObserver(name: String, block: @escaping (Notification) -> Void) -> RYNotificationObserver {
  2.     let observer = RYNotificationObserver(name: name, block: block)
  3.     observers.append(observer)
  4.     return observer
  5. }

  1. addObserver
方法用于注册观察者。在这个实现中，我们创建了一个新 
  1. RYNotificationObserver
对象并将其添加到 
  1. observers
数组。这个方法返回观察者对象，以便稍后从 
  1. NotificationCenter
中移除。

4、在 NotificationCenter 中添加发送通知的方法

  1. /// 发送通知的本质是利用了观察者模式
  2. /// 让观察者数组执行闭包中的代码
  3. func post(name: String, userInfo: [AnyHashable: Any]? = nil) {
  4.     let notification = Notification(name: Notification.Name(name), userInfo: userInfo)
  5.     observers
  6.         .filter({ $0.name == name })
  7.         .forEach { $0.block(notification) }
  8. }

  1. post
方法用来发送通知，它接受通知名以及可选的
  1. userInfo
字典。同时参数都包装在
  1. Notification
对象中，然后遍历 
  1. observers
数组。如果观察者的名称和通知名称匹配，我们将执行保存的
  1. block
。

5、在NotificationCenter中添加移除通知者的方法

  1. func removeObserver(_ observer: RYNotificationObserver) {
  2.     if let index = observers.firstIndex(where: { $0 === observer }) {
  3.         observers.remove(at: index)
  4.     }
  5. }

  1. removeObserver
方法用于移除观察者。它接受一个观察者对象并从 
  1. observers
数组中移除它。

NotificationCenter的源码分析

普遍来说，现在分析 

  1. NotificationCenter
的源码，一般是 github.com/gnustep/lib… ，这是在 gnustep 库的源码中，它和官方的具体实现肯定是有差异的，但是可以以它为参考的对象，在这里通知的源码使用了三个主要的类：

  • NSNotification

  • NSNotificationCenter

  • NSNotificationQueue

NSNotificationCenter 实现

用于在观察者和发送者之间发送通知，这是核心类，它的方法和Objective-C是一致的，使用 

  1. **addObserver:selector:name:object:
方法来添加观察者，但是它在内部使用了C语言实现链表的数据结构 
  1. Obs
存储观察者相关的信息：
  1. typedef struct Obs {
  2.   id observer;     /* Object to receive message. */
  3.   SEL selector;     /* Method selector. */
  4.   struct Obs *next; /* Next item in linked list. */
  5.   int retained;     /* Retain count for structure. */
  6.   struct NCTbl *link; /* Pointer back to chunk table */
  7. } Observation;

而在 

  1. postNotificationName:object:userInfo:
方法执行的时候会通过通知名找到封装好的 
  1. Obs
观察者，然后执行相应的方法：
  1. - (void) postNotificationName: (NSString*)name
  2.       object: (id)object
  3.     userInfo: (NSDictionary*)info
  4. {
  5.   // 先封装好notification
  6.   GSNotification *notification;
  7.   notification = (id)NSAllocateObject(concrete, 0, NSDefaultMallocZone());
  8.   notification->_name = [name copyWithZone: [self zone]];
  9.   notification->_object = [object retain];
  10.   notification->_info = [info retain];
  11.   [self _postAndRelease: notification];
  12. }
  13. // 然后调用观察者的selector方法
  14. - (void) _postAndRealse: (NSNotification*)notification {
  15. ......
  16. [o->observer performSelector: o->selector withObject: notification];
  17. ......
  18. }

当然，要将封装好的 

  1. notification
，作为参数传递给观察者需要执行的 
  1. selector
。

NSNotification 实现

那么 Notifiation 呢？它是一个包含了通知的名称、发送者对象以及用户信息字典的不可变对象。

  1. - (id) initWithCoder: (NSCoder*)aCoder
  2. {
  3.   NSString *name;
  4.   id object;
  5.   NSDictionary *info;
  6.   id n;
  7.   [aCoder decodeValueOfObjCType: @encode(id) at: &name];
  8.   [aCoder decodeValueOfObjCType: @encode(id) at: &object];
  9.   [aCoder decodeValueOfObjCType: @encode(id) at: &info];
  10.   n = [NSNotification notificationWithName: name object: object userInfo: info];
  11.   RELEASE(name);
  12.   RELEASE(object);
  13.   RELEASE(info);
  14.   DESTROY(self);
  15.   return RETAIN(n);
  16. }

NSNotificationQueue 的实现

最后是 NSNotificationQueue 的实现，它是一个用于管理通知发送的队列，可以按照特定的发送模式（例如合并相同的通知或按发送顺序）将通知排队。

  1. - (void) enqueueNotification: (NSNotification*)notification postingStyle:(NSPostingStyle)postingStyle coalesceMask: (NSUInteger)coalesceMask forModes: (NSArray*)modes
  2. {
  3.     if (modes == nil)
  4.     {
  5.       modes = defaultMode;
  6.     }
  7.     if (coalesceMask != NSNotificationNoCoalescing)
  8.     {
  9.       [self dequeueNotificationsMatching: notification coalesceMask: coalesceMask];
  10.     }
  11.     switch (postingStyle) {
  12.         case NSPostNow: {
  13.             NSString *mode;
  14.             mode = [[NSRunLoop currentRunLoop] currentMode];
  15.             if (mode == nil || [modes indexOfObject: mode] != NSNotFound)
  16.             {
  17.                 [_center postNotification: notification];
  18.             }
  19.         }
  20.         break;
  21.       case NSPostASAP:
  22.             add_to_queue(_asapQueue, notification, modes, _zone);
  23.             break;
  24.       case NSPostWhenIdle:
  25.             add_to_queue(_idleQueue, notification, modes, _zone);
  26.             break;
  27.     }
  28. }

当使用 

  1. NSNotificationQueue
的时候，就不需要我们手动发送 Notification 了，
  1. NSNotificationQueue
会自动帮我们发送，在上述代码中，如果是 
  1. NSPostNow
，那么通知会立马被发送，否则就先加入队列中：
  1. _asapQueue
或者 
  1. _idleQueue
，然后在合适的时候执行队列中的通知，比如：
  1. void GSPrivateNotifyIdle(NSString *mode) {
  2.     NotificationQueueList *item;
  3.     for (item = currentList(); item; item = item->next)
  4.     {
  5.         if (item->queue) {
  6.             notify(item->queue->_center,
  7.                    item->queue->_idleQueue,
  8.                    mode,
  9.                    item->queue->_zone);
  10.         }
  11.     }
  12. }

问题：如果

  1. NotificationCenter
添加的观察者是self，会造成循环引用吗？

答案是：不会！

NotificationCenter 对观察者的引用方式是弱引用(weak)，而不是强持有(strong)。因此，当一个对象被销毁时，它的 

  1. deinit
方法会被调用，即使它是一个观察者。所以即使我们不在 
  1. deinit
方法中添加移除 self 的操作也是可以的，因为 NotificationCenter 并没有对观察者强持有。

问题：如果 

  1. NotificationCenter
添加的是 block ，而 block 强持有了 self ，这会造成循环引用吗？

答案是：会！

从iOS 9开始，如果使用了基于 block 的观察者，那么就需要去小心观察者的生命周期了，因为

  1. NotificationCenter
对添加的 block 是强持有的，正如上述简单实现中的那样，它对闭包中捕获的变量就也是强持有的，所以为了避免这种现象，需要确保使用 
  1. [weak self]
来捕获列表。

在实际使用的时候，由于编码惯性，可能会在 

  1. deinit
方法中移除基于 block 的观察者以解决该问题：
  1. class ViewController: UIViewController {
  2.     private weak var observer: NSObjectProtocol!
  3.     func addObserver() {
  4.         observer = NotificationCenter.default.addObserver(forName: NSNotification.Name("test"), object: nil, queue: OperationQueue.main) { _ in
  5.             self.view.backgroundColor = UIColor.white
  6.         }
  7.     }
  8.     deinit {
  9.         NotificationCenter.default.removeObserver(observer!)
  10.     }
  11. }

但是在这种情况下， 

  1. deinit
方法并不会执行！ 原因就是 
  1. NotificationCenter
持有了 block, 也间接持有了 self，而 
  1. NotificationCenter
是一个单例，所以这种持有关系是一直存在的，导致了 
  1. deinit
方法并不会执行！

问题：观察者的 

  1. selector
执行的线程和发送通知的线程有关吗？

答案是：正相关！

从上文中的简单实现以及GNU的源码中基本可以看出结论了。添加观察者的线程并没有什么影响，而发送通知的线程，其实就是调用方法执行的线程，所以两者是在同一线程执行的。

  1. func addObserver() {
  2.     NotificationCenter.default.addObserver(self, selector: #selector(click), name: NSNotification.Name.init("test"), object: nil)
  3.     DispatchQueue.global().async {
  4.         NotificationCenter.default.post(name: NSNotification.Name.init("test"), object: nil)
  5.         NSLog("curretThread1: (Thread.current)")
  6.     }
  7. }
  8. @objc func click() {
  9.     NSLog("curretThread2: (Thread.current)")
  10. }
  11. // curretThread2: <NSThread: 0x600001358240>{number = 6, name = (null)}
  12. // curretThread1: <NSThread: 0x600001358240>{number = 6, name = (null)}

同时还需要注意的就是通知发送，然后 

  1. selector
被执行，这个过程其实本质上是一个观察者模式的实现方式，同时，它也是同步执行的，再执行完发送消息的方法后就会去寻找对应的 
  1. Observer
，找到之后就执行相应的 
  1. selector
，执行完之后，发送消息的方法才执行完毕了。

所以发送通知和监听通知执行方法的核心是：相同线程执行 且 同步执行。

以上就是NotificationCenter类的实现原理是什么的详细内容，更多关于NotificationCenter类的实现原理是什么的资料请关注九品源码其它相关文章！

相关热词： 实现原理是什么
上一篇：讲一讲如何在一个页面中使用多个百度分享按钮，分享不同的文章
下一篇：C++11中的std::function怎么使用

文章分类

IT资讯 CMS教程 服务器 数据库 前端开发 后端开发 工具使用 其他教程

最后更新

热门排行

网站首页 | 关于我们 | 免责声明 | 网站建设 | 在线工具 | 网站地图

版权声明：本站发布的资源部分自互联网，所有资源版权归原作者所有。如果有侵犯到您的权益，请联系本站删除，谢谢合作！

Copyright 2018-2025 ©19jp.com All Rights Reserved. 陕ICP备16002142号-1