练习 05 内存/pool/arc/循环引用/通知机制(多代理)

在分析 ARC 相关源码之前，需要对 isa 有一定了解，其中存储了一些非常重要的信息，下面是 isa 的结构组成：

工会/联盟union isa_t 
{
    Class cls;
    uintptr_t bits;
    struct {
         uintptr_t nonpointer        : 1;//->表示使用优化的isa指针
         uintptr_t has_assoc         : 1;//->是否包含关联对象
         uintptr_t has_cxx_dtor      : 1;//->是否设置了析构函数，如果没有，释放对象更快
         uintptr_t shiftcls          : 33; // MACH_VM_MAX_ADDRESS 0x1000000000 
                                               ->类的指针
         uintptr_t magic             : 6;//->固定值,用于判断是否完成初始化
         uintptr_t weakly_referenced : 1;//-> 对象是否被弱引用
         uintptr_t deallocating      : 1;//-> 对象是否正在销毁
         uintptr_t has_sidetable_rc  : 1;//1->在extra_rc存储引用计数将要溢出的时候,
                                         借助Sidetable(散列表)存储引用计数,
                                         has_sidetable_rc设置成1
        uintptr_t extra_rc          : 19;  //->存储引用计数
    };
};

其中nonpointer、weakly_referenced、has_sidetable_rc和extra_rc都是 ARC 有直接关系的成员变量，其他的大多也有涉及到。

objc_release

这里我们需要自己在NSTimer的分类中添加类方法:

@implementation NSTimer (BlcokTimer)

+ (NSTimer *)bl_scheduledTimerWithTimeInterval:(NSTimeInterval)interval block:(void (^)(void))block repeats:(BOOL)repeats {
    
    return [self scheduledTimerWithTimeInterval:interval target:self selector:@selector(bl_blockSelector:) userInfo:[block copy] repeats:repeats];
}

+ (void)bl_blockSelector:(NSTimer *)timer {
    
    void(^block)(void) = timer.userInfo;
    if (block) {
        block();
    }
}

__weak typeof(self) weakSelf = self;
self.timer = [NSTimer bl_scheduledTimerWithTimeInterval:1 block:^{
     [weakSelf changeText];
} repeats:YES];

@interface PFProxy : NSProxy

//通过创建对象
- (instancetype)initWithObjc:(id)object;

//通过类方法创建创建
+ (instancetype)proxyWithObjc:(id)object;

@end
@interface ZYWeakObject()

@property (weak, nonatomic) id weakObject;

@end

@implementation ZYWeakObject

- (instancetype)initWithWeakObject:(id)obj {
    _weakObject = obj;
    return self;
}

+ (instancetype)proxyWithWeakObject:(id)obj {
    return [[ZYWeakObject alloc] initWithWeakObject:obj];
}

/**
 * 消息转发，让_weakObject响应事件
 */
- (id)forwardingTargetForSelector:(SEL)aSelector {
    return _weakObject;
}

- (void)forwardInvocation:(NSInvocation *)invocation {
    void *null = NULL;
    [invocation setReturnValue:&null];
}

- (BOOL)respondsToSelector:(SEL)aSelector {
    return [_weakObject respondsToSelector:aSelector];
}

接下来就可以这样使用中间件了： 

// target要设置成weakObj，实际响应事件的是self
ZYWeakObject *weakObj = [ZYWeakObject proxyWithWeakObject:self];
self.timer = [NSTimer scheduledTimerWithTimeInterval:1 target:weakObj 
                 selector:@selector(changeText) userInfo:nil repeats:YES];

这种实现在几个方面受到限制。

OC的常用的消息传递方式有很多种，代理、通知、block、kvo等，
不同的实现方式有不同的应用场景，也有各自的优缺点。普通的代理模式只能应用与1对1的场景，针对1对多的场景只能被迫选择使用通知。

但是通知也有自己的缺点：

1. 在编译期间不会检查通知是否能够被观察者正确的处理；

2. 在释放通知的观察者时，需要在通知中心移除观察者；（iOS9以前）

3. 在调试的时候，通知传递的过程很难控制和跟踪；

4. 发送通知和接收通知时需要提前知道通知名称，如果通知名称不一致，会出现不同步的情况；

5. 通知发出后，不能从观察者获得任何的反馈信息。对于需要返回值的场景没有办法处理。

如果代理模式能支持多个响应对象，那么就不会再有以上的问题。

如果不想修改第三方库的代码，怎么办，难道要在外面再封装一层吗？想想以后的维护工作就让人头疼。

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface NVMMultiDelegate : NSObject

@property (nonatomic, readonly) NSPointerArray *delegates;

- (void)addDelegate:(id)delegate;
- (void)removeDelegate:(id)delegate;

@end

NS_ASSUME_NONNULL_END

对外仅暴露 readonly的 delegates，和增删 delegate的方法。

- (instancetype)init {
  if (self = [super init]) {
    _delegates = [NSPointerArray weakObjectsPointerArray];
  }
  return self;
}

在初始化 delegates的 Ivars的时候，指定其按照弱引用的内存管理方式来跟踪集合内的指针

- (void)addDelegate:(id)delegate {
  [_delegates addPointer:(__bridge void*)delegate];
}  

- (void)removeDelegate:(id)delegate {
  NSUInteger index = [self indexOfDelegate:delegate];
  if (index != NSNotFound) {
    [_delegates removePointerAtIndex:index];
  }
  [_delegates compact];
}

- (NSUInteger)indexOfDelegate:(id)delegate {
  for (NSUInteger i = 0; i < _delegates.count; i += 1) {
    if ([_delegates pointerAtIndex:i] == (__bridge void*)delegate) {
      return i;
    }
  }
  return NSNotFound;
}
  

- (BOOL)respondsToSelector:(SEL)aSelector {
  if ([super respondsToSelector:aSelector]) {
    return YES;
  }
  for (id delegate in _delegates) {
    if (delegate && [delegate respondsToSelector:aSelector]) {
      return YES;
    }
  }
  return NO;
}  

- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector {
  NSMethodSignature *signature = [super methodSignatureForSelector:aSelector];
  if (signature) {
    return signature;
  }
  [_delegates compact]; //***这个方法可以帮助你去掉数组里面的野指针，
                          //避免你在快速遍历的时候拿到一个指向不存在对象的地址
  for (id delegate in _delegates) {
    if (!delegate) {
      continue;
    }
    signature = [delegate methodSignatureForSelector:aSelector];
    if (signature) {
      break;
    }
  }
  return signature;
}

建立一个连接需要三次握手，而终止一个连接要经过四次挥手（也有将四次挥手叫做四次握手的）。
这由TCP的半关闭（half-close）造成的。所谓的半关闭，其实就是TCP提供了连接的一端在结束它的发送后还能接收来自另一端数据的能力。

因为当    服务端收到客户端的SYN连接请求报文后，可以直接发送SYN+ACK报文。
其中ACK报文是用来应答的，SYN报文是用来同步的。

但是关闭连接时，当服务端收到FIN报文时，很可能并不会立即关闭SOCKET，所以只能先回复一个ACK报文，告诉客户端，"你发的FIN报文我收到了"。

只有等到我服务端所有的报文都发送完了，我才能发送FIN报文，因此不能一起发送。故需要四次挥手。

Ping-Pong通常用来验证TCP连接的有效性. 具体来说, 如果Ping-Pong正常, 那么证明连接有效, 数据传输没有问题, 反之, 要么连接已断开, 要么连接还在但服务器已经过载无力进行恢复, 此时客户端可以选择断开重连或者切换服务器.

文件下载/上传?

到目前为止, 我们讨论的都是类似DataTask的数据请求, 并未涉及到文件下载/上传请求, 事实上, 我也没打算在通讯协议上加上这两种请求的支持. 这部分我是这样考虑的:

如果传输的文件比较小, 那么仿照HTTP直接给协议加上ContentType字段, Content以特殊分隔符进行分隔即可.

如果传输的文件比较大, 那么直接在当前连接进行文件传输可能会阻塞其他的数据传输, 这是我们不希望看到的, 所以一定是另起一条连接专用于大文件传输. 考虑到文件传输不太可能像普通数据传输那样需要即时性和服务端推送, 为了节省服务端开销, 文件传输完成后连接也没有必要继续保持. 这里的"建立连接-文件传输-断开连接"其实已经由HTTP实现得很好了, 而且功能还多, 我们没必要再做重复工作.

翻译：NSProxy是一个抽象的超类，它定义了一个对象的API，用来充当其他对象或者一些不存在的对象的替身。
通常，发送给Proxy的消息会被转发给实际对象，或使Proxy加载（转化为）实际对象。
 NSProxy的子类可以用于实现透明的分布式消息传递(例如，NSDistantObject)，或者用于创建开销较大的对象的惰性实例化。

13.NSPointerArray

几个特点：

• NSPointerArray可以存放nil
• 可以插入删除nil
• count 属性可以设置 （用nil占位）
• 可以初始化以保持对对象的强引用或弱引用，也可以根据NSPointerFunctionsOptions定义的任何内存或个性选项进行初始化
• NSCopying和NSCoding协议仅在指针数组初始化为保持对对象的强引用或弱引用时才适用
• 遵循 NSFastEnumeration，可以通过 for...in 来进行遍历