NSNotificationCenter底层探究

最新推荐文章于 2023-07-31 20:08:00 发布
最新推荐文章于 2023-07-31 20:08:00 发布
阅读量619 收藏 2
点赞数
分类专栏： iOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/streamery/article/details/115963752
版权

文章目录

简单介绍及使用

通知，简单来说就是，一方使用name发送通知，持有与之相同name的另一方接收通知并进行处理（如果添加的观察者name为空，那么就会接收所有通知）。特点是基本上不用考虑其它影响因素，只需要使用同样的通知名称，监听该通知的对象（即观察者）再对通知做出反应即可。降低耦合度

swift版使用

// 添加观察者 这个方法一定要是@objc
// 可以发现 这个方法的name为可选值，可以为nil
NotificationCenter.default.addObserver(self, selector: #selector(test), name: NSNotification.Name.init("test"), object: nil)
// 发送通知
// name不是可选值，必须得有名字
NotificationCenter.default.post(name: NSNotification.Name.init("test"), object: nil, userInfo: nil)

ObjectiveC版使用

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(test) name:@"test" object:nil];
 [[NSNotificationCenter defaultCenter] postNotificationName:@"test" object:nil];

从使用代码中可以看出来，NSNotificationCenter是一个单例

底层

NSNotificationCenter - 消息中心

GNUStep的源码
创建源码:

static NSNotificationCenter *default_center = nil;

+ (NSNotificationCenter*) defaultCenter
{
  return default_center;
}

NSNotificationCenter内部主要定义了两个表和一个链表，还有一个对象结构体

typedef struct NCTbl {
  Observation       *wildcard;  /* Get ALL messages. */
  GSIMapTable       nameless;   /* Get messages for any name. */
  GSIMapTable       named;      /* Getting named messages only. */
} NCTable

typedef struct  Obs {
  id        observer;   /* Object to receive message.   */
  SEL       selector;   /* Method selector.     */
  struct Obs    *next;      /* Next item in linked list.    */
  int       retained;   /* Retain count for structure.  */
  struct NCTbl  *link;      /* Pointer back to chunk table  */
} Observation;

还有一些宏定义，下面会用到

#define        TABLE                ((NCTable*)_table)
#define        WILDCARD             (TABLE->wildcard)
#define        NAMELESS             (TABLE->nameless)
#define        NAMED                (TABLE->named)
#define        LOCKCOUNT            (TABLE->lockCount)
  1. named
    添加观察者时传入了 NotificationName 的表
  2. nameless
    添加观察者时没有传入 NotificationName 的表
  3. wildcard
    添加观察者时既没有传入 NotificationName ，又没有传入object，就会加在这个链表上

named表

named表是一个嵌套表，外层以 NotificationName 为key，在注册观察者时可以传入一个object参数，所以内层是以 object 为 key，Observation 为 value，又因为可以多个对象观察同一个对象，所以Observation 是一个链表，这一整个key-value表作为外层的value，大概图长这个样子：
在这里插入图片描述
PS：我们在实际开发中，经常会将object设为nil，这时系统会根据nil自动生成一个key，之后所有object为nil的观察者都会使用这个key，换句话说，这个key对应了所有object为nil的观察者

nameless表

有了named表，nameless表应该不难想象，因为没有 NotificationName ，所以少了named表外层的key，将value单独拎出来就组成了named表。也就是，以object为key，Observation为value，结构图为：
在这里插入图片描述

wildcard链表

named表是有 NotificationName 的表，nameless是没有 NotificationName 只有 object 的表，那么wildcard 当然就是兜底啦，既没有 NotificationName 也没有 object 的观察者就都存放在这里，也就是只有 Observation 这么一个值了，用链表连接在一起即可。在这里的观察者会接收到所有通知
在这里插入图片描述

添加观察者

使用方法addObserver:selector:name:object
根据GNUStep上的源码一步步分析：

- (void) addObserver: (id)observer
            selector: (SEL)selector
                name: (NSString*)name
              object: (id)object
{
  Observation        *list;
  Observation        *o;
  GSIMapTable        m;
  GSIMapNode        n;
// observer为空时的报错
  if (observer == nil)
    [NSException raise: NSInvalidArgumentException
                format: @"Nil observer passed to addObserver ..."];
// selector为空时的报
  if (selector == 0)
    [NSException raise: NSInvalidArgumentException
                format: @"Null selector passed to addObserver ..."];
// observer不能响应selector时的报错
  if ([observer respondsToSelector: selector] == NO)
    {
      [NSException raise: NSInvalidArgumentException
        format: @"[%@-%@] Observer '%@' does not respond to selector '%@'",
        NSStringFromClass([self class]), NSStringFromSelector(_cmd),
        observer, NSStringFromSelector(selector)];
    }
// 给表上锁
  lockNCTable(TABLE);
// 建立一个新Observation
  o = obsNew(TABLE, selector, observer);
// 如果有name
  if (name) {
  // 在named表中 以name为key寻找value
      n = GSIMapNodeForKey(NAMED, (GSIMapKey)(id)name);
      // named表中没有value
      if (n == 0) {
          // 新建一个表
          m = mapNew(TABLE);
          // 由于这是对给定名称的首次观察，因此我们对该名称进行了复制，以便在map中无法对其进行更改（来自GNUStep的注释）
          name = [name copyWithZone: NSDefaultMallocZone()];
          // 新建表作为name的value添加在named表中
          GSIMapAddPair(NAMED, (GSIMapKey)(id)name, (GSIMapVal)(void*)m);
          GS_CONSUMED(name)
      } else {
      // 取出对应的value
          m = (GSIMapTable)n->value.ptr;
      }
      // 将observation添加到正确object的列表中
      n = GSIMapNodeForSimpleKey(m, (GSIMapKey)object);
      // n是object的value
      if (n == 0) {
          o->next = ENDOBS;
          // 将o作为object的value链表的头结点插入
          GSIMapAddPair(m, (GSIMapKey)object, (GSIMapVal)o);
      } else {
          // 在链表尾部加入o
          list = (Observation*)n->value.ptr;
          o->next = list->next;
          list->next = o;
      }
      // 这个else if 就是没用name有object的 Observation，对object进行的操作相同，
  } else if (object) {
      n = GSIMapNodeForSimpleKey(NAMELESS, (GSIMapKey)object);
      if (n == 0) {
          o->next = ENDOBS;
          GSIMapAddPair(NAMELESS, (GSIMapKey)object, (GSIMapVal)o);
      } else {
          list = (Observation*)n->value.ptr;
          o->next = list->next;
          list->next = o;
      }
 } else {
 // 既没有name又没有object，就加在WILDCARD链表中
      o->next = WILDCARD;
      WILDCARD = o;
 }
// 解锁
  unlockNCTable(TABLE);
}

总结

  1. 首先会根据传入的observer，selector创建一个Observation
  2. 查看是否存在name
    2.1 存在：以name为key去找对应的value，如果有，则取出value；如果没有，新建一个table，以name为key存进named表中。
    2.2 不存在：直接进入步骤3
  3. 在object表中，寻找以传入的object为key的链表，如果有，在尾部加入之前实例化好的Observation；如果没有，就将Observation实例作为头结点插入object的value链表
  4. 如果既没有name又没有object，就加在WILDCARD链表中

发送通知

使用方法postNotification:， postNotificationName:object:userInfo或者postNotificationName:object:，后者默认userInfo为nil
同样使用GNUStep源码进行分析

- (void) postNotification: (NSNotification*)notification {
  if (notification == nil) {
      [NSException raise: NSInvalidArgumentException
                  format: @"Tried to post a nil notification."];
    }
  [self _postAndRelease: RETAIN(notification)];
}

- (void) postNotificationName: (NSString*)name
                       object: (id)object {
  [self postNotificationName: name object: object userInfo: nil];
}


- (void) postNotificationName: (NSString*)name
                       object: (id)object
                     userInfo: (NSDictionary*)info {
  GSNotification        *notification;

  notification = (id)NSAllocateObject(concrete, 0, NSDefaultMallocZone());
  notification->_name = [name copyWithZone: [self zone]];
  notification->_object = [object retain];
  notification->_info = [info retain];
  [self _postAndRelease: notification];
}

可以看到，三个方法殊途同归，都调用了_postAndRelease:方法。不同的是，postNotification:方法外部直接传了一个NSNotification对象，其他两个方法都是内部进行了处理包装 成为了一个NSNotification对象
再看看_postAndRelease:方法做了什么

- (void) _postAndRelease: (NSNotification*)notification {
  Observation        *o;
  unsigned        count;
  NSString        *name = [notification name];
  id                object;
  GSIMapNode        n;
  GSIMapTable        m;
  GSIArrayItem        i[64];
  GSIArray_t        b;
  GSIArray        a = &b;
   // name为空的报错
  if (name == nil) {
      RELEASE(notification);
      [NSException raise: NSInvalidArgumentException
                  format: @"Tried to post a notification with no name."];
    }
  object = [notification object];

  GSIArrayInitWithZoneAndStaticCapacity(a, _zone, 64, i);
  lockNCTable(TABLE);
  // 查找所有未指定name或object的观察者，加在a数组中
  for (o = WILDCARD = purgeCollected(WILDCARD); o != ENDOBS; o = o->next)
    {
      GSIArrayAddItem(a, (GSIArrayItem)o);
    }
// 查找与通知的object相同但是没有name的观察者，加在a数组中
  if (object) {
      n = GSIMapNodeForSimpleKey(NAMELESS, (GSIMapKey)object);
      if (n != 0) {
          o = purgeCollectedFromMapNode(NAMELESS, n);
          while (o != ENDOBS) {
              GSIArrayAddItem(a, (GSIArrayItem)o);
              o = o->next;
            }
        }
    }

  // 查找name的观察者，但观察者的非零对象与通知的object不匹配时除外，加在a数组中
  if (name) {
  // 先匹配name
      n = GSIMapNodeForKey(NAMED, (GSIMapKey)((id)name));
      if (n) {
      // 从匹配的name对应的value表中继续查找
          m = (GSIMapTable)n->value.ptr;
      } else {
          m = 0;
      }
      if (m != 0) {
          // 首先，查找与通知的object相同的观察者
          n = GSIMapNodeForSimpleKey(m, (GSIMapKey)object);
          if (n != 0) {
              o = purgeCollectedFromMapNode(m, n);
              while (o != ENDOBS) {
                  GSIArrayAddItem(a, (GSIArrayItem)o);
                  o = o->next;
                }
            }

          if (object != nil) {
          // 接着是没有object的观察者
              n = GSIMapNodeForSimpleKey(m, (GSIMapKey)nil);
              if (n != 0) {
                  o = purgeCollectedFromMapNode(m, n);
                  while (o != ENDOBS) {
                      GSIArrayAddItem(a, (GSIArrayItem)o);
                      o = o->next;
                    }
                }
            }
        }
    }
  unlockNCTable(TABLE);

  // 发送所有通知
  count = GSIArrayCount(a);
  while (count-- > 0) {
      o = GSIArrayItemAtIndex(a, count).ext;
      if (o->next != 0) {
          NS_DURING {
          // 给observer发送selector，让其处理
              [o->observer performSelector: o->selector
                                withObject: notification];
            }
          NS_HANDLER {
              BOOL        logged;
              // 尝试将通知与异常一起报告，但是如果通知本身有问题，我们只记录异常。
              NS_DURING
                NSLog(@"Problem posting %@: %@", notification, localException);
                logged = YES;
              NS_HANDLER
                logged = NO;
              NS_ENDHANDLER
                if (NO == logged)
                { 
                  NSLog(@"Problem posting notification: %@", localException);
                }  
            }
          NS_ENDHANDLER
        }
    }
  lockNCTable(TABLE);
  GSIArrayEmpty(a);
  unlockNCTable(TABLE);

  RELEASE(notification);
}

总结

  1. 首先创建一个observers数组存储需要发通知的observer（源码中为a数组）
  2. 先遍历wildcard链表，将所有observer添加到observers数组中
  3. 若存在object，在nameless表中查找与通知的object相同的观察者，加入observers数组中
  4. 若存在name，在named表中先查找name对应的table，再在table中查找与通知的object相同的观察者，加入observers数组中。如果 object 不 为nil，则再以 nil 为 key 找到对应的链表，遍历链表，将 observer 添加到 observers 数组中
  5. 最后再遍历observers数组，通知observer需要处理selector
    这种处理通知的方式也就能说明，发送通知的线程和接收通知的线程是同一线程

移除通知

注意 在iOS9之前需要手动调用removeObserver:方法进行释放，如果在对象释放后没有及时移除通知，在对象释放之后再发送通知可能会造成野指针crash；但是在iOS9之后，通知中心持有的观察者由unsafe_unretained引用变为weak引用。即使不对观察者手动移除，持有的观察者的引用也会在观察者被回收后自动置空。但是通过addObserverForName:object: queue:usingBlock:方法注册的观察者需要手动释放，因为通知中心持有的是它们的强引用。如果使用 Block 的方式进行添加的，一定要持有对象，在释放的时候，需要自己手动进行释放操作，不然会出现对象释放了，但是发送通知的时候，block还是会被调用，此时 bolck 中的 self 对象已经是 nil 了
GNUStep源码：

- (void) removeObserver: (id)observer {
  if (observer == nil)
    return;

  [self removeObserver: observer name: nil object: nil];
}

- (void) removeObserver: (id)observer
                   name: (NSString*)name
                 object: (id)object {
  if (name == nil && object == nil && observer == nil)
      return;

  lockNCTable(TABLE);
  // name和object都为nil，就在wildcard链表里删除
  if (name == nil && object == nil) {
      WILDCARD = listPurge(WILDCARD, observer);
    }
   // name为空时
  if (name == nil) {
      GSIMapEnumerator_t        e0;
      GSIMapNode                n0;
       // 首先尝试删除为此object设置的所有命名项目
       // 在named表中
      e0 = GSIMapEnumeratorForMap(NAMED);
      n0 = GSIMapEnumeratorNextNode(&e0);
      while (n0 != 0) {
          GSIMapTable                m = (GSIMapTable)n0->value.ptr;
          NSString                *thisName = (NSString*)n0->key.obj;

          n0 = GSIMapEnumeratorNextNode(&e0);
          if (object == nil) {
          // 清空named表
              GSIMapEnumerator_t        e1 = GSIMapEnumeratorForMap(m);
              GSIMapNode                n1 = GSIMapEnumeratorNextNode(&e1);

              while (n1 != 0) {
                  GSIMapNode        next = GSIMapEnumeratorNextNode(&e1);

                  purgeMapNode(m, n1, observer);
                  n1 = next;
                }
          } else {
          // 以object为key找到对应链表，清空链表
              GSIMapNode        n1;
              n1 = GSIMapNodeForSimpleKey(m, (GSIMapKey)object);
              if (n1 != 0) {
                  purgeMapNode(m, n1, observer);
                }
            }
          if (m->nodeCount == 0) {
              mapFree(TABLE, m);
              GSIMapRemoveKey(NAMED, (GSIMapKey)(id)thisName);
            }
        }
        // 开始操作nameless表
      if (object == nil) {
      // 清空nameless表
          e0 = GSIMapEnumeratorForMap(NAMELESS);
          n0 = GSIMapEnumeratorNextNode(&e0);
          while (n0 != 0) {
              GSIMapNode        next = GSIMapEnumeratorNextNode(&e0);

              purgeMapNode(NAMELESS, n0, observer);
              n0 = next;
            }
        } else {
        // 找到对应的observer链表，清空
          n0 = GSIMapNodeForSimpleKey(NAMELESS, (GSIMapKey)object);
          if (n0 != 0) {
              purgeMapNode(NAMELESS, n0, observer);
            }
        }
   } else {
      GSIMapTable                m;
      GSIMapEnumerator_t        e0;
      GSIMapNode                n0;

      n0 = GSIMapNodeForKey(NAMED, (GSIMapKey)((id)name));
      // 如果没有和这个name相同的key，直接返回
      if (n0 == 0) {
          unlockNCTable(TABLE);
          return;                /* Nothing to do.        */
      }
      m = (GSIMapTable)n0->value.ptr;

      if (object == nil) {
      // 如果object为nil，就清空找到的table
          e0 = GSIMapEnumeratorForMap(m);
          n0 = GSIMapEnumeratorNextNode(&e0);

          while (n0 != 0) {
              GSIMapNode        next = GSIMapEnumeratorNextNode(&e0);

              purgeMapNode(m, n0, observer);
              n0 = next;
            }
      } else {
       // 清空object对应的链表
          n0 = GSIMapNodeForSimpleKey(m, (GSIMapKey)object);
          if (n0 != 0) {
              purgeMapNode(m, n0, observer);
            }
        }
        // 清除named表中的作为key的name
      if (m->nodeCount == 0) {
          mapFree(TABLE, m);
          GSIMapRemoveKey(NAMED, (GSIMapKey)((id)name));
        }
    }
  unlockNCTable(TABLE);
}

总结

  1. 若NotificationName和object都为nil，则清空wildcard链表。
  2. 若NotificationName为nil，遍历named table，若object为nil，则清空named table，若object不为nil，则以object为key找到对应的链表，然后清空链表。在nameless table中以object为key找到对应的observer链表，然后清空，若object也为nil，则清空nameless table
  3. 若NotificationName不为nil，在named table中以NotificationName为key找到对应的table，若object为nil，则清空找到的table，若object不为nil，则以object为key在找到的table中取出对应的链表，然后清空链表

参考文献

GNUStep源码
NSNotificationCenter使用总结
底层初窥——NSNotificationCenter

Tuski-
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
iOS之深入解析通知NSNotification的底层原理
╰つ栺尖篴夢ゞ
07-10 7674
一、概念 ① NSNotification NSNotification 用于描述通知的类，一个 NSNotification 对象就包含了一条通知的信息，NSNotification 对象是不可变的。所以当创建一个通知时通常包含如下属性： @interface NSNotification : NSObject <NSCopying, NSCoding> @property (readonly, copy) NSNotificationName name; @property (
ios NSNotificationCenter通知的简单使用
01-04
通知类本身比较简单，大概就分为注册通知监听器、发送通知，注销通知监听器三个方法；通知中心（NSNotificationCenter）采用单例的模式，整个系统只有一个通知中心，通过如下代码获取: //获取通知中心 [NSNotificationCenter defaultCenter]； 注册通知监听器方法： //observer为监听器 //aSelector为接到收通知后的处理函数 //aName为监听的通知的名称 //object为接收通知的对象，需要与postNotification的object匹配，否则接收不到通知 - (void)addObserver:(id)observe
NSNotificationCenter的理解和运用 教程
ACERROR
09-28 1470
通知中心：实现了一对多的消息传递，可以实现跨页面传递。 cocoa消息机制算是同步的，观察者只要向消息中心注册，即可接受其他对象发送来的消息，消息发送者和消息接受者两者可以互相一无所知，完全解耦。这种消息机制可以用应用于任意时间和任何对象，观察者可以有多个。所以消息具有广播的性质，注意：观察者向消息中心注册以后，在不需要接受消息时需要向中心注销，属于典型的观察者模式。 消息通知中重要的两个类： 1）NSNotificationCenter：实现NSNotificationCenter的原理是一个观察者模式，
NSNotificationCenter简单概述
砥砺前行的博客
11-20 1141
一、NSNotificationCenter 和delegate 的区别 是使用 观察者模式 来实现的用于跨层传递消息的机制 （无需代理，双方无需建立关系） KVO也是观察者模式 NSNotificationCenter 是使用观察者模式 delegate是使用通知者 NSNotificationCenter 是一对多
NotificationCenter 文档教程(SwiftUI Foundation 中文手册)
iCloudEnd的博客
08-07 1528
NotificationCenter 通知分派机制可将信息广播到注册的观察者。 class NotificationCenter : NSObject 总览 对象在通知中心注册，以NSNotification使用或方法接收通知（对象）。当对象将自己添加为观察者时，它指定应接收的通知。因此，对象可以多次调用此方法，以将其注册为多个不同通知的观察者。addObserver(_:selector:name:object:)addObserver(forName:object:queue:using:) 每个正在
NSNotificationCenter 通知使用方法详解
热门推荐
什么都不会的小菜鸟
10-13 1万+
你要知道的KVC、KVO、Delegate、Notification都在这里转载请注明出处 http://www.jianshu.com/p/f6224f075437本系列文章主要通过讲解KVC、KVO、Delegate、Notification的使用方法，来探讨KVO、Delegate、Notification的区别以及相关使用场景，本系列文章将分一下几篇文章进行讲解，读者可按需查阅。 KVC 使
iOS NSNotificationCenter通知中心使用小结
08-26
iOS中的NSNotificationCenter是系统提供的一种消息传递机制，它允许对象发布通知，其他对象可以注册接收这些通知，从而实现不同对象间的数据同步或者事件响应。在iOS开发中，NSNotificationCenter经常与Delegate模式...
NSNotificationCenter 的使用
07-26
`NSNotificationCenter` 是苹果 macOS 和 iOS 开发中的一个关键组件，属于Foundation框架的一部分，它提供了一个广播消息机制，使得对象可以在不直接引用彼此的情况下进行通信。这个机制被称为“观察者模式”或...
网络连接 与 NSNotificationCenter
03-23
标题 "网络连接 与 NSNotificationCenter" 涉及到的是iOS开发中的两个核心概念：网络状态监测和应用程序的通知中心机制。这篇博文可能讨论了如何利用苹果的 Reachability 框架来检测设备的网络状态，并结合 ...
NSNotificationCenter通知
zxcsai的博客
10-13 245
NSNotificationCenter 相比与 Delegate 可以实现更大的跨度的通信机制，可以为多个无引用关系的对象进行通信。 利用通知逆向传值：通知的使用首先注册获取通知中心单例  (1)       //1.获取通知中心         NSNotificationCenter *center = [NSNotificationCenter defaultCenter];
NSVotificationCenter在Swift中添加了addObserver
w36680130的博客
06-01 1701
How do you add an observer in Swift to the default notification center? 如何在Swift中将观察者添加到默认通知中心？ I'm
ios_notificationCenter
weixin_41672404的博客
08-13 165
let observer = NotificationCenter.default.addObserver( forName: UIResponder.keyboardDidChangeFrameNotification, object: nil, queue: nil) { (notification) in print("test") 效果 点击框外蓝条消失 class CopyableTextView: UITextView { o...
6、NSNotificationCenter使用
zwcshy的专栏
03-27 429
一个NSNotificationCenter对象(通知中心)提供了在程序中广播消息的机制，它实质上就是一个通知分发表。这个分发表负责维护为各个通知注册的观察者，并在通知到达时，去查找相应的观察者，将通知转发给他们进行处理。 本文主要了整理了一下NSNotificationCenter的使用及需要注意的一些问题，并提出了一些未解决的问题，希望能在此得到解答。 获取通知中心 每个程序
iOS NSNotificationCenter简介
假装你是大灰狼的专栏
11-18 1043
NSNotificationCenter通知是一种消息广播的实现机制，可以在不同对象之间发送通知进而实现通信。
【iOS】通知原理
最新发布
m0_63852285的博客
07-31 986
我们可以通过看通知的实现机制来了解通知中心是怎么实现对观察者的引用的。由于苹果对Foundation源码是不开源的，我们具体就参考一下GNUStep的源码实现。, 具体源码可以进行查看。
swift通知 NotificationCenter的使用
wa172126691的博客
01-17 8710
1.扩展通知的名字方便使用 //通知名字扩展 extension Notification.Name { //更新视图 static let MyNotificationUpdateViewController = Notification.Name(rawValue:&quot;updateViewController&quot;) } 2.注册通知/移除通知 //创建通知中心,设置监听的方法 ...
NSNotificationCenter defaultCenter 通知的简单实用
sinat_29814399的博客
09-09 1824
今天改一个需求，在tableView cell里加了一个幻灯片，但是点击事件突然不知道怎么办，同事提醒了下用通知，后来搜了下，NSNotificationCenter方法，cell里写通知传参，view里接受通知，写了跳转方法，完美解决之前遇到的bug，分享下。      [[NSNotificationCenter defaultCenter] addObserver:self selec
NSNotificationCenter
weixin_30678821的博客
01-31 77
新建一个继承于UIViewControll的类，并在.m中添加如下代码 -(void)doSomeThing:(NSNotification *)aNote{ NSDictionary *dict = [aNote object]; NSLog(@"%@",dict);}- (void)loadView{ [super loadView]; NSString *myS...
nsnotificationcenter
04-06
b'nsnotificationcenter' 是一个 Objective-C 类，它可以用于在 iOS 和 macOS 应用程序中发送和接收通知。通过向 NSNotificationCenter 注册观察者对象，应用程序可以接收到与特定主题相关的通知。这些通知可以包含自定义数据，帮助应用程序在不同部分之间共享信息和状态。NSNotificatinoCenter 是iOS和macOS中通知机制的关键组件之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值