RACDisposable

rac中用来销毁订阅者的类。其有4个子类：

• RACCompoundDisposable：它可以包含多个 disposable 对象，并且支持手动添加和移除 disposable 对象
• RACKVOTrampoline： 代表一次 KVO 观察，并且可以用来停止观察
• RACScopedDisposable：当它被 dealloc 的时候调用本身的 -dispose 方法
• RACSerialDisposable:作为 disposable 的容器使用，可以包含一个 disposable 对象，并且允许将这个 disposable 对象通过原子操作交换出来

父类RACDisposable，相当于一次性任务

在初始化RACSignal子类的时候block会返回一个RACDisposable对象

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        [subscriber sendNext:@"111"];
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"1");
        }];
    }];

就是这个return nil。 在信号被销毁的时候会打印：1。

RACDisposable的.h如下：

@interface RACDisposable : NSObject

//只读属性，用来判断是否已经释放
@property (atomic, assign, getter = isDisposed, readonly) BOOL disposed;

//初始化方法
+ (instancetype)disposableWithBlock:(void (^)(void))block;

//手动销毁
- (void)dispose;

//返回一个RACScopedDisposable对象，更换作用域
- (RACScopedDisposable *)asScopedDisposable;

@end

.m文件最重要实现是：

- (void)dispose {
void (^disposeBlock)(void) = NULL;

    while (YES) {
        void *blockPtr = _disposeBlock;
        if (OSAtomicCompareAndSwapPtrBarrier(blockPtr, NULL, &_disposeBlock)) {
            if (blockPtr != (__bridge void *)self) {
                disposeBlock = CFBridgingRelease(blockPtr);
            }

            break;
        }
    }

    if (disposeBlock != nil) disposeBlock();
    }

其中：
OSMemoryBarrier：是汇编层面的一个的一个方法，就是用来设置内存屏障，它即可以用于读操作，也可以用于写操作。
CFBridgingRetain：将一个OC对象转为非ARC对象并交出内存管理的能力。
CFBridgingRelease：讲一个非ARC对象转换为一个非ARC的对象。
OSAtomicCompareAndSwapPtrBarrier：比较两个地址是否相同

这段代码的作用是，首先，创建一个disposeBlock的block对象，该函数会判断 blockPtr 所指向的地址是否与 &__ disposeBlock 内存地址中存储的指针地址相同，若相同，则将 NULL 保存到 &_disposeBlock 内存地址中。

即当 blockPtr == *(&_disposeBlock) 为 YES 时，并且 blockPtr 并不是指向 self 时，则其所指向的代码块便会被执行，执行完毕后，代码块即可被释放。

RACCompoundDisposable,多个任务

RACCompoundDisposable可以添加多个RACDisposable任务，.h文件如下：

//初始化一个空的RACCompoundDisposable对象
+ (instancetype)compoundDisposable;
//初始化时添加一个的Disposable数组
+ (instancetype)compoundDisposableWithDisposables:(nullable NSArray *)disposables;

//添加
- (void)addDisposable:(nullable RACDisposable *)disposable;
//删除
- (void)removeDisposable:(nullable RACDisposable *)disposable;

@end

RACCompoundDisposable中创建了

RACDisposable *_inlineDisposables[RACCompoundDisposableInlineCount];

CFMutableArrayRef _disposables;

在只聚合两个的时候用C数组，在大于两个的时候将后面两个添加到foundation数组中

具体分析见ReactiveCocoa学习笔记六-RACDisposable源码分析

RACSerialDisposable,可以用来交换未处理任务

先来看下头文件：

@interface RACSerialDisposable : RACDisposable

//当前持有的任务
@property (atomic, strong, nullable) RACDisposable *disposable;

//通过一个任务初始化一个任务
+ (instancetype)serialDisposableWithDisposable:(nullable RACDisposable *)disposable;

//交换一个未处理的任务，如果处理过了那么新的任务会立刻进入完成状态
{
if (alreadyDisposed) {
        [newDisposable dispose];
        return nil;
    }}返回的是老的信号

- (nullable RACDisposable *)swapInDisposable:(nullable RACDisposable *)newDisposable;

@end

RACScopedDisposable,包装了一层，与父类的区别是在dealloc的时候回自动调用dispose

RACKVOTrampoline

这个类是用在观察模式中，在介绍之前先介绍两个文件：

• NSObject+RACDeallocating
• RACKVOProxy

第一个文件,是为了给NSObject添加一个replay信号，其实现了dealloc的方法交换，在Object销毁时会自动调用信号的销毁。

//销毁前执行的任务
@property (atomic, readonly, strong) RACCompoundDisposable *rac_deallocDisposable;

//一个监听销毁的信号
- (RACSignal *)rac_willDeallocSignal;

id newDealloc = ^(__unsafe_unretained id self) {
RACCompoundDisposable *compoundDisposable = objc_getAssociatedObject(self, RACObjectCompoundDisposable);
[compoundDisposable dispose];

if (originalDealloc == NULL) {
    struct objc_super superInfo = {
                  .receiver = self,
                    .super_class = class_getSuperclass(classToSwizzle)
   };

void (*msgSend)(struct objc_super *, SEL) = (__typeof__(msgSend))objc_msgSendSuper;
                msgSend(&superInfo, deallocSelector);
            } else {
                originalDealloc(self, deallocSelector);
            }
        };

第二个文件，只是对kvo观察者及keypath的管理。

@interface RACKVOProxy : NSObject

//单例
+ (instancetype)sharedProxy;

//添加观察者
- (void)addObserver:(__weak NSObject *)observer forContext:(void *)context;

//移除观察者
- (void)removeObserver:(NSObject *)observer forContext:(void *)context;

@end

里面使用NSMapTable实现的
RACKVOTrampoline 这个类.h只有一个初始化方法

//
// target   - 观察者目标
// observer -观察者，可以为nil
// keyPath  - 观察路径，可以为nil
// options  - 观察选项
// block    - 回调

/
- (instancetype)initWithTarget:(__weak NSObject *)target observer:(__weak NSObject *)observer keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block;

接下来，我们看下.m的实现:

- (instancetype)initWithTarget:(__weak NSObject *)target observer:(__weak NSObject *)observer keyPath:(NSString *)keyPath options:(NSKeyValueObservingOptions)options block:(RACKVOBlock)block {
    NSCParameterAssert(keyPath != nil);
    NSCParameterAssert(block != nil);

    NSObject *strongTarget = target;
    if (strongTarget == nil) return nil;

    self = [super init];
   //赋值
    _keyPath = [keyPath copy];
   
    _block = [block copy];
    _weakTarget = target;
    _unsafeTarget = strongTarget;
    _observer = observer;
   
   //将监听对象和key值一对一添加到RACKVOProxy的但李忠
    [RACKVOProxy.sharedProxy addObserver:self forContext:(__bridge void *)self];
    //RACKVOProxy添加对监听对象的监听
    [strongTarget addObserver:RACKVOProxy.sharedProxy forKeyPath:self.keyPath options:options context:(__bridge void *)self];
   //监听对象和监听者添加销毁任务，都需要加，这里在对象销毁的时候这个任务不会销毁。
    [strongTarget.rac_deallocDisposable addDisposable:self];
    [self.observer.rac_deallocDisposable addDisposable:self];

    return self;
}

NSObject *target;
    NSObject *observer;

    @synchronized (self) {
        _block = nil;

        //这里销毁全局对象只留下局部对象
        target = self.unsafeTarget;
        observer = self.observer;

        _unsafeTarget = nil;
        _observer = nil;
    }
    //监听者和被监听者都移除这个任务
    [target.rac_deallocDisposable removeDisposable:self];
    [observer.rac_deallocDisposable removeDisposable:self];
    //移除监听和map
    [target removeObserver:RACKVOProxy.sharedProxy forKeyPath:self.keyPath context:(__bridge void *)self];
    [RACKVOProxy.sharedProxy removeObserver:self forContext:(__bridge void *)self];