deallocating,deallocated的使用

我们通常将deallocating序列结合takeUntil使用。达到当对象销毁时,序列会自动销毁的目的。

  let vc = LGDetialViewController()
        _ = vc.publicOB
            .takeUntil(vc.rx.deallocating)
        .subscribe(onNext: { (item) in
            print("订阅到 \(item)")
        })
        self.navigationController?.pushViewController(vc, animated: true)

本文对deallocating序列源码进行解析,了解RxSwift是如何监控一个对象的释放,并给订阅者发送消息的。

deallocating源码解析

想要精确知道一个对象的是否销毁,那就必须掌握对象dealloc方法是否执行。掌握dealloc方法是否执行,很容易就想到runtime的方法交换。RxSwift也是通过方法交换的方式实现的吗?我们进入源码一探究竟。

private let deallocSelector = NSSelectorFromString("dealloc")
   public var deallocating: Observable<()> {
        return self.synchronized {
            do {
                let proxy: DeallocatingProxy = try self.registerMessageInterceptor(deallocSelector)
                return proxy.messageSent.asObservable()
            }
            catch let e {
                return Observable.error(e)
            }
        }
    }

首先调用registerMessageInterceptor创建DeallocatingProxy对象. 参数是dealloc的Selector。
dealloc在ARC下不允许直接@seleteror(dealloc)，采用NSSelectorFromString("dealloc")方式解决。

  fileprivate func registerMessageInterceptor<T: MessageInterceptorSubject>(_ selector: Selector) throws -> T {
       ......
       var error: NSError?
        let targetImplementation = RX_ensure_observing(self.base, selector, &error)
        if targetImplementation == nil {
            throw error?.rxCocoaErrorForTarget(self.base) ?? RxCocoaError.unknown
        }

        subject.targetImplementation = targetImplementation!

        return subject
    }

通过方法名称,我们推测RX_ensure_observing应该是我们要分析的重要方法。

IMP __nullable RX_ensure_observing(id __nonnull target, SEL __nonnull selector, NSErrorParam error) {
    __block IMP targetImplementation = nil;
    // Target is the second object that needs to be synchronized to TRY to make sure other swizzling framework
    // won't do something in parallel.
    // Even though this is too fine grained locking and more coarse grained locks should exist, this is just in case
    // someone calls this method directly without any external lock.
    @synchronized(target) {
        // The only other resource that all other swizzling libraries have in common without introducing external
        // dependencies is class object.
        //
        // It is polite to try to synchronize it in hope other unknown entities will also attempt to do so.
        // It's like trying to figure out how to communicate with aliens without actually communicating,
        // save for the fact that aliens are people, programmers, authors of swizzling libraries.
        @synchronized([target class]) {
            [[RXObjCRuntime instance] performLocked:^(RXObjCRuntime * __nonnull self) {
                targetImplementation = [self ensurePrepared:target
                                               forObserving:selector
                                                      error:error];
            }];
        }
    }

    return targetImplementation;
}

进入方法-(IMP __nullable)ensurePrepared:(id __nonnull)target forObserving:(SEL __nonnull)selector error:(NSErrorParam)error
经过查找，我们找到下面的关键代码

 if (![self swizzleDeallocating:deallocSwizzingTarget error:error]) {
            return nil;
        }

SWIZZLE_INFRASTRUCTURE_METHOD(
    void,
    swizzleDeallocating,
    ,
    deallocSelector,
    DEALLOCATING_BODY
)

这个方法用宏实现的。Swift下没有Load方法,使用宏定义预编译。使用宏可以获得更高的代码运行效率。
把这个宏还原成下列方法:

    - (BOOL)swizzleDeallocating:(Class __nonnull)class error:(NSErrorParam)error
        {
            SEL selector = deallocSelector;
        
        __unused SEL rxSelector = RX_selector(selector);
        IMP (^newImplementationGenerator)(void) = ^() {
        __block IMP thisIMP = nil;
        id newImplementation = ^void(__unsafe_unretained id self         DECLARE_ARGUMENTS(__VA_ARGS__)) {
        DEALLOCATING_BODY(__VA_ARGS__)
        
        struct objc_super superInfo = {
        .receiver = self,
        .super_class = class_getSuperclass(class)
        };
        
        void (*msgSend)(struct objc_super *, SEL DECLARE_ARGUMENTS(__VA_ARGS__))
        = (__typeof__(msgSend))objc_msgSendSuper;
        @try {
        return msgSend(&superInfo, selector ARGUMENTS(__VA_ARGS__));
        }
        @finally { NO_BODY(__VA_ARGS__) }
        };
        
        thisIMP = imp_implementationWithBlock(newImplementation);
        return thisIMP;
        };
        
        IMP (^replacementImplementationGenerator)(IMP) = ^(IMP originalImplementation) {
        __block void (*originalImplementationTyped)(__unsafe_unretained id, SEL DECLARE_ARGUMENTS(__VA_ARGS__) )
        = (__typeof__(originalImplementationTyped))(originalImplementation);
        
        __block IMP thisIMP = nil;
        id implementationReplacement = ^void(__unsafe_unretained id self DECLARE_ARGUMENTS(__VA_ARGS__) ) {
        DEALLOCATING_BODY(__VA_ARGS__)
        @try {
        return originalImplementationTyped(self, selector ARGUMENTS(__VA_ARGS__));
        }
        @finally { NO_BODY(__VA_ARGS__) }
        };
        
        thisIMP = imp_implementationWithBlock(implementationReplacement);
        return thisIMP;
        };
        
        return [self ensureSwizzledSelector:selector
        ofClass:class
        newImplementationGenerator:newImplementationGenerator
        replacementImplementationGenerator:replacementImplementationGenerator
        error:error];
        }

进入-(BOOL)ensureSwizzledSelector:(SEL __nonnull)selector ofClass:(Class __nonnull)class newImplementationGenerator:(IMP(^)(void))newImplementationGenerator replacementImplementationGenerator:(IMP (^)(IMP originalImplementation))replacementImplementationGenerator error:(NSErrorParam)error方法

 IMP originalImplementation = method_getImplementation(existingMethodOnTargetClass);
  
    IMP implementationReplacementIMP = replacementImplementationGenerator(originalImplementation);

    IMP originalImplementationAfterChange = method_setImplementation(existingMethodOnTargetClass, implementationReplacementIMP);

代码中通过method_getImplementation获取dealloc当前的IMP originalImplementation，
然后获取要替换的IMPimplementationReplacementIMP，然后使用method_setImplementation为existingMethodOnTargetClassMethod设置新的IMP。

到目前为止,我们已经验证deallocating序列是通过runtime的方式为交换delloc的实现,从而实现对对象释放的监控。
当对象调用dealloc方法，会进入replacementImplementationGenerator这个IMP

   IMP (^replacementImplementationGenerator)(IMP) = ^(IMP originalImplementation) {
        __block void (*originalImplementationTyped)(__unsafe_unretained id, SEL DECLARE_ARGUMENTS(__VA_ARGS__) )
        = (__typeof__(originalImplementationTyped))(originalImplementation);
        
        __block IMP thisIMP = nil;
        id implementationReplacement = ^void(__unsafe_unretained id self DECLARE_ARGUMENTS(__VA_ARGS__) ) {
        DEALLOCATING_BODY(__VA_ARGS__)
        @try {
        return originalImplementationTyped(self, selector ARGUMENTS(__VA_ARGS__));
        }
        @finally { NO_BODY(__VA_ARGS__) }
        };
        
        thisIMP = imp_implementationWithBlock(implementationReplacement);
        return thisIMP;
        };

IMP中先执行DEALLOCATING_BODY(__VA_ARGS__)，然后调用dealloc交换前的IMP.
DEALLOCATING_BODY也是宏实现的

#define DEALLOCATING_BODY(...)                                                        \
    id<RXDeallocatingObserver> observer = objc_getAssociatedObject(self, rxSelector); \
    if (observer != nil && observer.targetImplementation == thisIMP) {                \
        [observer deallocating];                                                      \
    }

代码中调用[observer deallocating],观察者是关联属性rxSelector,我们追溯到registerMessageInterceptor方法中, 知道序列的观察者是DeallocatingProxy
那么[observer deallocating]会来到DeallocatingProxy. deallocating()

@objc func deallocating() {
            self.messageSent.on(.next(()))
        }

DeallocatingProxy中保存ReplaySubject序列

  let messageSent = ReplaySubject<()>.create(bufferSize: 1)

DeallocatingProxy.deallocating()中对messageSent序列发送响应。
发送响应后，那么就会有订阅者来接收。由于deallocating和takeUntil经常结合起来使用,那么分析一下takeUntil的源码，探索一下takeUntil内部是如何接收deallocating发送的响应非常有必要。想要了解takeUntil源码,请查阅RxSwift-TakeUntil源码分析

至此,deallocating的源码分析已经完成,deallocated的实现与deallocating基本一致，这里就不再赘述了。

总结:

1.创建序列messageSent,返回到外界。
2.通过method-swizzing监控对象的dealloc
3.当调用对象的dealloc,为messageSent发送响应.

deallocating.png