//通知对象(其实可以理解成一个消息对象)
@interface NSNotification : NSObject <NSCopying, NSCoding>
//通知名称,通知的唯一标识
@property (readonly, copy) NSNotificationName name;  
//发送通知的对象,谁发出通知,nil:匿名发送
@property (nullable, readonly, retain) id object;    
//发送方在发送消息的同时想要传递的参数
@property (nullable, readonly, copy) NSDictionary *userInfo;  
初始化方法创建通知 对象
- (instancetype)initWithName:(NSNotificationName)name object:(nullable id)object  
userInfo:(nullable NSDictionary *)userInfo;
- (nullable instancetype)initWithCoder:(NSCoder *)coder NS_DESIGNATED_INITIALIZER;
类方法创建通知对象
+ (instancetype)notificationWithName:(NSNotificationName)aName   
object:(nullable id)anObject;
+ (instancetype)notificationWithName:(NSNotificationName)aName   
object:(nullable id)anObject userInfo:(nullable NSDictionary *)aUserInfo;
不能通过init创建对象对象 /* do not invoke; not a valid initializer for this class */
- (instancetype)init /*API_UNAVAILABLE(macos, ios, watchos, tvos)*/;    

通知中心
@interface NSNotificationCenter : NSObject {
    @package
    void *_impl;
    void *_callback;
    void *_pad[11];
}
//通知中心(单例)，程序只有一个通知中心
@property (class, readonly, strong) NSNotificationCenter *defaultCenter; 
1.在通知中心添加观察者
- (void)addObserver:(id)observer selector:(SEL)aSelector name:(nullable NSNotificationName)  
aName object:(nullable id)anObject;
2.向通知中心发送通知
- (void)postNotification:(NSNotification *)notification;
- (void)postNotificationName:(NSNotificationName)aName object:(nullable id)anObject;
- (void)postNotificationName:(NSNotificationName)aName object:(nullable id)anObject  
userInfo:(nullable NSDictionary *)aUserInfo;
3.移除通知中心中的观察者
- (void)removeObserver:(id)observer;
- (void)removeObserver:(id)observer name:(nullable NSNotificationName)aName   
object:(nullable id)anObject;
 以block的形式代替selector方式为通知中心添加观察者，并且也可以设置操作队列
- (id <NSObject>)addObserverForName:(nullable NSNotificationName)name   
object:(nullable id)obj queue:(nullable NSOperationQueue *)queue   
usingBlock:(void (^)(NSNotification *note))block API_AVAILABLE(macos(10.6), ios(4.0), watchos(2.0), tvos(9.0));

@implementation WGMainObjcVC

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
    //1.向通知中心注册一个观察者，当观察者接收到通知的时候，会去调用change方法
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(change)   
    name:@"customStr" object:nil];
}

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    //2.向通知中心发送通知 方式一、二任选其一
    //方式一
    [[NSNotificationCenter defaultCenter] postNotificationName:@"customStr" object:nil];
    //方式二
    NSNotification *notification = [NSNotification notificationWithName:@"customStr" object:nil];
    [[NSNotificationCenter defaultCenter] postNotification:notification];
}

//3.当通知中心收到通知消息时，会将通知消息发送给观察者，观察者收到通知后调用change方法
-(void)change {
    NSLog(@"变化了");
}

-(void)viewWillDisappear:(BOOL)animated {
    //4.页面消失的时候 从通知中心移除观察者 方式一、二任选其一
    //方式一: 移除通知中心中针对观察者的所有通知
    [[NSNotificationCenter defaultCenter] removeObserver:self];
    //方式二: 移除通知中心中针对观察者的名字为customStr的通知
    [[NSNotificationCenter defaultCenter] removeObserver:self name:@"customStr" object:nil];
}
@end

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
    //1.向通知中心注册一个观察者
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(change:)   
    name:@"customStr" object:nil];
}

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    //2.向通知中心发送通知，在通知中携带信息
    NSDictionary *dataDic = @{@"name": @"zhangsan", @"age": @18};
    [[NSNotificationCenter defaultCenter] postNotificationName:@"customStr"   
    object:nil userInfo:dataDic];
}

//3.当通知中心收到通知消息时，会将通知消息发送给观察者，观察者收到通知后调用change方法
-(void)change:(NSNotification *)noti {
    NSDictionary *dic = noti.userInfo;
    NSLog(@"变化了--%@",dic);
}

打印结果:变化了--{
        age = 18;
        name = zhangsan;
        }

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(change:)   
    name:@"customStr" object:nil];
}

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    [[NSNotificationCenter defaultCenter] postNotificationName:@"customStr"   
    object:nil userInfo:nil];
}

-(void)change:(NSNotification *)noti {
    NSLog(@"通知名称:%@,通知对象:%@,通知携带参数:%@",noti.name,noti.object,noti.userInfo);
}

-(void)viewWillDisappear:(BOOL)animated {
    [[NSNotificationCenter defaultCenter] removeObserver:self name:@"customStr" object:nil];
}

* 当post中的object为nil,add中的object为nil，可以接收到通知
* 当post中的object为nil,add中的object不为nil，接收不到通知
* 当post中的object不为nil,add中的object为nil，可以接收到通知
* 当post中的object不为nil,add中的object不为nil，可以接收到通知

//方式一： 移除观察者所有的通知
[[NSNotificationCenter defaultCenter] removeObserver:self];
//方式二: 移除观察者中[通知名称是customStr 发送通知对象是123]的通知
[[NSNotificationCenter defaultCenter] removeObserver:self name:@"customStr" object:@"123"];

@implementation WGMainObjcVC

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor redColor];
    //queue参数: 就是将usingBlock提交到queue队列里面执行，一般是设置为主队列用于更新UI，  
    主队列任务都是在主线程中更新的
    [[NSNotificationCenter defaultCenter] addObserverForName:@"customStr" object:nil  
    queue:[NSOperationQueue mainQueue] usingBlock:^(NSNotification * _Nonnull note) {
        NSLog(@"通知名称:%@,通知对象:%@,通知携带参数:%@",note.name,note.object,note.userInfo);
    }];
}

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    [[NSNotificationCenter defaultCenter] postNotificationName:@"customStr" object:nil];
}

-(void)change:(NSNotification *)noti {
    NSLog(@"通知名称:%@,通知对象:%@,通知携带参数:%@",noti.name,noti.object,noti.userInfo);
}

@end

打印结果: 通知名称:customStr,通知对象:(null),通知携带参数:(null)

@interface NSNotificationQueue : NSObject {
@property (class, readonly, strong) NSNotificationQueue *defaultQueue;
初始化方法来关联外部的通知中心，最终也是通过通知中心来管理通知的发送、注册
- (instancetype)initWithNotificationCenter:(NSNotificationCenter *)notificationCenter NS_DESIGNATED_INITIALIZER;

- (void)enqueueNotification:(NSNotification *)notification postingStyle:(NSPostingStyle)postingStyle;
- (void)enqueueNotification:(NSNotification *)notification postingStyle:(NSPostingStyle)postingStyle  
coalesceMask:(NSNotificationCoalescing)coalesceMask forModes:(nullable NSArray<NSRunLoopMode> *)modes;

- (void)dequeueNotificationsMatching:(NSNotification *)notification coalesceMask:(NSUInteger)coalesceMask;

@end

设置通知什么时候发送
typedef NS_ENUM(NSUInteger, NSPostingStyle) { 
    NSPostWhenIdle = 1,     当runloop处于空闲时发出通知
    NSPostASAP = 2,           在当前通知调用或者计时器结束发出通知
    NSPostNow = 3              在合并通知完成之后立即发出通知
};

设置如何合并通知
typedef NS_OPTIONS(NSUInteger, NSNotificationCoalescing) { 
    NSNotificationNoCoalescing = 0,              不合并通知
    NSNotificationCoalescingOnName = 1,     按照通知名字合并通知
    NSNotificationCoalescingOnSender = 2    按照传入的object(发送推送的对象)合并通知
};

根容器，NSNotificationCenter持有
typedef struct NCTbl {
  Observation    *wildcard;  //链表结构，保存既没有name也没有object的通知 
  MapTable       nameless;   //存储没有name但是有object的通知
  MapTable       named;      //存储带有name的通知，不管有没有object
} NCTable;

Observation 存储观察者和响应结构体，基本的存储单元
typedef struct  Obs {
  id        observer;   观察者,接收通知消息的对象
  SEL       selector;   观察者接收到通知后执行的方法
  struct Obs    *next;  下一个观察者对象的地址
  int       retained;   /* Retain count for structure.  */
  struct NCTbl  *link;      /* Pointer back to chunk table  */
} Observation;

// 根容器，NSNotificationCenter持有
typedef struct NCTbl {
  Observation   *wildcard;    链表结构，保存既没有name也没有object的通知
  GSIMapTable   nameless;     存储没有name但是有object的通知    
  GSIMapTable   named;        存储带有name的通知，不管有没有object    
    ...
} NCTable;

//Observation 存储观察者和响应结构体，基本的存储单元
typedef struct Obs {
  id   observer;      观察者，接收通知的对象    
  SEL  selector;      响应方法        
  struct Obs *next;   Next item in linked list.  
  ...
} Observation;

/*
 observer：观察者，即通知的接收者   selector：接收到通知时的响应方法
 name: 通知name                 object：携带对象
 */
-(void)addObserver:(id)observer selector:(SEL)aSelector name:(nullable NSNotificationName)aName
object:(nullable id)anObject {
    //1.创建一个observation对象，持有观察者和SEL，下面进行的所有逻辑就是为了存储它
    o = obsNew(TABLE, aSelector, observer);
    
    // case1: 如果aName存在
    if (aName) {
        //NAMED是个宏，表示名为named字典。以aName为key，从named表中获取对应的mapTable
        n = GSIMapNodeForKey(NAMED, (GSIMapKey)(id)aName);
        if (n == 0) {
            //不存在，则创建
            m = mapNew(TABLE);  //先取缓存，如果缓存没有则新建一个map
            GSIMapAddPair(NAMED, (GSIMapKey)(id)aName, (GSIMapVal)(void*)m);
        }else {
            //存在则把值取出来 赋值给m
            m = (GSIMapTable)n->value.ptr;
        }
    
        //以anObject为key，从字典m中取出对应的value，其实value被MapNode的结构包装了一层，这里不追究细节
        n = GSIMapNodeForSimpleKey(m, (GSIMapKey)anObject);
        if (n == 0) {
            //不存在，则创建,然后将新创建的observation对象进行保存
            o->next = ENDOBS;
            GSIMapAddPair(m, (GSIMapKey)anObject, (GSIMapVal)o);
        }else {
            //存在，则将新创建的observation对象进行保存
            list = (Observation*)n->value.ptr;
            o->next = list->next;
            list->next = o;
        }
        //case2: 如果name为空，但object不为空
    }else if (anObject) { 
        //以anObject为key，从nameless字典中取出对应的value，value是个链表结构
        n = GSIMapNodeForSimpleKey(NAMELESS, (GSIMapKey)anObject);
        if (n == 0) {
            //不存在则新建链表，并存到map中
            o->next = ENDOBS;
            GSIMapAddPair(NAMELESS, (GSIMapKey)object, (GSIMapVal)o);
        }else {
            //存在 则把值接到链表的节点上
        }
    }else { //case3: name 和 object 都为空
        // 则存储到wildcard链表中
        o->next = WILDCARD;
        WILDCARD = o;
    }
}

    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(receiveBusTypeNotification:) name:WGNotificationName_BusTypeName object:nil];
    若添加观察者时，通知名称name存在，则存储在name表中(以name为key找到name表中的)
    若添加观察者时，通知名称name不存在但object存在，则存储在nameless表中
    若添加观察者时，name、object都为空，则存储到wildcard链表中
        
    wildcard  链表
    name      哈希表  [name: [object]]
    nameless  哈希表

public class WGTestNotification : WGBaseVC {
    public override func layoutUI() {
        self.title = "收银员"
        self.addNavBackBtn()
        //向通知中心注册观察者
        NotificationCenter.default.addObserver(self, selector: #selector(getNotification(noti:)), 
        name: nil, object: nil)
    }
    
    @objc func getNotification(noti: NSNotification) {
        let userInfoDic = noti.userInfo
        NSLog("收到的通知内容:\(userInfoDic)")
    }
    
    public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        NotificationCenter.default.post(name: NSNotification.Name.init("A"), object: nil,  
        userInfo: ["A": "a"])
    }
    
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
}

public override func layoutUI() {
    self.title = "测试通知"
    self.addNavBackBtn()
    //向通知中心注册观察者
    NotificationCenter.default.addObserver(self, selector: #selector(getNotification(notifi:)),  
    name: NSNotification.Name.init("111"), object: nil)
}

public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    //通知中心发送通知
    self.notificationCenterSendNotification()
}

@objc func getNotification(notifi: Notification) {
    NSLog("2.get notification message")
}

//1. 通知中心发送通知
private func notificationCenterSendNotification() {
    NSLog("1.before send notification")
    NotificationCenter.default.post(name: NSNotification.Name("111"), object: nil, userInfo: nil)
    NSLog("3.after send notification")
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

打印结果：1.before send notification
        2.get notification message
        3.after send notification

public override func layoutUI() {
    self.title = "收银员"
    self.addNavBackBtn()
    //向通知中心注册观察者
    NotificationCenter.default.addObserver(self, selector: #selector(getNotification(notifi:)),   
    name: NSNotification.Name.init("111"), object: nil)
}


public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    //通知队列发送通知
    self.queueSendNotification()
}

@objc func getNotification(notifi: Notification) {
    NSLog("2.get notification message")
}

//2. 通知队列发送通知
private func queueSendNotification() {
    NSLog("1.before send notification")
    //创建通知对象、通知队列对象，将通知放到通知队列中
    let notifi = Notification.init(name: NSNotification.Name.init(rawValue: "111"), object: nil)
    let notifiQueue = NotificationQueue.default
    /*
     postingStyle: 通知的发送时机
     enum PostingStyle: UInt{
     case whenIdle = 1 runloop空闲时发送通知，简单地说就是当本线程的runloop空闲时即发送通知到通知中心--异步执行132(延迟执行)
     case asap = 2  (As Soon As Possible)尽可能快的发送，这种时机是穿插在每次事件完成期间来做的--异步执行132(延迟执行)
     case now = 3  立刻发送或者合并通知完成之后发送，NotificationCenter就是这种方式发送的--同步执行的123
     }
     
     coalesceMask: 通知合并的策略,有些时候同名通知只想存在一个，这时候就可以用到它了
     struct NotificationCoalescing : OptionSet {
     var none    默认不合并
     var onName  只要name相同，就认为是相同通知,合并相同名称的通知
     var onSender object相同，就认为是相同通知，合并相同object的通知
     }
     forModes:[RunLoop.Mode]?
     当指定了某种特定runloop mode后，该通知只有在当前runloop为指定mode的下，才会被发出。
     */
    notifiQueue.enqueue(notifi, postingStyle: NotificationQueue.PostingStyle.whenIdle,   
    coalesceMask: NotificationQueue.NotificationCoalescing.onName, forModes: nil)
    NSLog("3.after send notification")
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

public override func layoutUI() {
    self.title = "收银员"
    self.addNavBackBtn()
    //向通知中心注册观察者
    NotificationCenter.default.addObserver(self, selector: #selector(getNotification(notifi:)),   
    name: NSNotification.Name.init("111"), object: nil)
}


public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    //子线程发送通知
    self.sendSubThreadNotification()
}

@objc func getNotification(notifi: Notification) {
    NSLog("2.get notification message---\(Thread.current)")
}

//主线程发通知
private func sendMainThreadNotification() {
    NSLog("1 before send--\(Thread.current)")
    NotificationCenter.default.post(name: NSNotification.Name.init("111"), object: nil, userInfo: nil)
    NSLog("3 after send--\(Thread.current)")
}

//子线程发送通知
private func sendSubThreadNotification() {
    DispatchQueue.global().async {
        NSLog("1 before send--\(Thread.current)")
        NotificationCenter.default.post(name: NSNotification.Name.init("111"), object: nil, userInfo: nil)
        NSLog("3 after send--\(Thread.current)")
    }
}

deinit {
    NotificationCenter.default.removeObserver(self)
}

打印结果: 1 before send--<NSThread: 0x283e8af00>{number = 7, name = (null)}
        2.get notification message---<NSThread: 0x283e8af00>{number = 7, name = (null)}
        3 after send--<NSThread: 0x283e8af00>{number = 7, name = (null)}

public class WGTestVC : WGBaseVC, NSMachPortDelegate {
    private var machPort: NSMachPort!
    public override func layoutUI() {
        self.title = "会员管理"
        self.addNavBackBtn()
        //1.将MachProt添加到主线程的Runloop中
        /*MachPort的工作方式
         1.将NSMachPort的对象添加到一个线程A所对应的RunLoop中
         2.并给NSMachPort对象设置相应的代理
         3.在其他线程B中调用该MachPort对象发消息时会在MachPort所关联的线程A中执行相关的代理方法。
        */
        NSLog("add before thread is \(Thread.current)")
        self.machPort = NSMachPort()
        self.machPort.setDelegate(self)
        RunLoop.current.add(self.machPort, forMode: .common)
        NSLog("add after thread is \(Thread.current)")
    }
    
    //NSMachPortDelegate
    public func handleMachMessage(_ msg: UnsafeMutableRawPointer) {
        NSLog("handleMachMessage thread is: \(Thread.current)")
    }
    
    public override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        //2.在子线程中通过NSMachPort对象发送消息，会在NSMachPort关联的线程中执行相关的代理方法
        DispatchQueue.global().async {
            NSLog("NSMachPort send message thread is: \(Thread.current)")
            self.machPort!.send(before: Date(), msgid: 100, components: nil, from: nil, reserved: 0)
        }
    }
}

打印结果： add before thread is <NSThread: 0x28053a840>{number = 1, name = main}
        add after thread is <NSThread: 0x28053a840>{number = 1, name = main}
        NSMachPort send message thread is: <NSThread: 0x2805862c0>{number = 14, name = (null)}
        handleMachMessage thread is: <NSThread: 0x28053a840>{number = 1, name = main}

public class WGTestVVVVV : WGBaseVC, NSMachPortDelegate {
    private var notificationArr = [Notification]() //存放子线程发出的所有通知
    private var mainThread = Thread.main           //处理通知事件的预期线程(这里预期线程用主线程)
    private var lock = NSLock()                    //对通知队列枷锁的锁对象，避免线程冲突
    private var machPort = NSMachPort()
    public override func layoutUI() {
        self.title = "会员管理"
        self.addNavBackBtn()
        //1.设置代理并将NSMachPort添加到主线程的Runloop中
        self.machPort.setDelegate(self)
        RunLoop.current.add(self.machPort, forMode: .common)
        
        //2. 主线程中添加观察者
        NotificationCenter.default.addObserver(self, selector: #selector(getNofiti(notifi:)),   
        name: NSNotification.Name.init("code"), object: nil)
        
        //3.在子线程中发送通知
        DispatchQueue.global().async {
            NotificationCenter.default.post(name: NSNotification.Name.init("code"), object: nil, userInfo: nil)
        }
    }
    
    //响应通知事件：子线程中收到通知后，将通知放入到通知队列中暂存(通知数组)，然后给主线程的RunLoop发送处理通知的消息
    @objc func getNofiti(notifi: Notification) {
        NSLog("收到通知 当前线程是:\(Thread.current)")
        if Thread.current == mainThread {  //处理出队列的通知(这里其实就是数组)
            NSLog("在当前主线程中执行任务: \(Thread.current)")
        }else {
            self.lock.lock()
            self.notificationArr.append(notifi)
            self.lock.unlock()
            //通过NSMachPort给处理通知的线程发送通知，使其处理队列中所暂存的队列
            self.machPort.send(before: Date(), components: nil, from: nil, reserved: 0)
        }
    }
    
    //NSMachPortDelegate
    public func handleMachMessage(_ msg: UnsafeMutableRawPointer) {
        NSLog("NSMachPort代理方法 当前线程是: \(Thread.current)")
        self.lock.lock()
        while self.notificationArr.count > 0 {
            //取出第一个通知，然后删除通知数组中的这个通知，然后处理从通知数组中取出的通知
            let notifi = self.notificationArr[0]
            self.notificationArr.remove(at: 0)
            
            self.lock.unlock()
            self.getNofiti(notifi: notifi)
            self.lock.lock()
        }
        self.lock.unlock()
    }
}

打印结果: 收到通知 当前线程是:<NSThread: 0x282636080>{number = 13, name = (null)}
        NSMachPort代理方法 当前线程是: <NSThread: 0x2826b2840>{number = 1, name = main}
        收到通知 当前线程是:<NSThread: 0x2826b2840>{number = 1, name = main}
        在当前主线程中执行任务: <NSThread: 0x2826b2840>{number = 1, name = main}