ReactiveCocoa理解

前端之家收集整理的这篇文章主要介绍了ReactiveCocoa理解前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

ReactiveCocoa 与信号

ReactiveCocoa 对于状态的理解与《失控》一书中十分类似,将原有的各种设计模式,包括代理、Target/Action、block、通知中心以及观察者模式各种『输入』,都抽象成了数据流或者信号(也可以理解为状态流)让单一的组件能够对自己的响应动作进行控制,简化了视图控制器的负担。

在 ReactiveCocoa 中最重要的信号,也就是RACSignal对象是这一篇文章介绍的核心;文章中主要会介绍下面的代码片段出现的内容

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
    [subscriber sendNext:@1];
    [subscriber sendNext:@2];
    [subscriber sendCompleted];
    return [RACDisposable disposableWithBlock:^{
        NSLog(@"dispose");
    }];
}];
[signal subscribeNext:^(id  _Nullable x) {
    @"%@",x);
}];

在上述代码执行时,会在控制台中打印出以下内容

1
2
dispose

代码片段基本都是围绕RACSignal类进行的,文章会分四部分对上面的代码片段的工作流程进行简单的介绍:

  • 简单了解RACSignal
  • 信号的创建
  • 信号的订阅与发送
  • 订阅的回收过程

RACSignal 简介

RACSignal其实是抽象类RACStream的子类,在整个 ReactiveObjc 工程中有另一个类RACSequence也继承自抽象类RACStream


RACSignal-Hierachy

RACSignal可以说是 ReactiveCocoa 中的核心类,也是最重要的概念,整个框架围绕着RACSignal的概念进行组织,对RACSignal最简单的理解就是它表示一连串的状态:

What-is-RACSigna

在状态改变时,对应的订阅RACSubscriber就会收到通知执行相应的指令,在 ReactiveCocoa 的世界中所有的消息都是通过信号的方式来传递的,原有的设计模式都会简化为一种模型,这篇文章作为 ReactiveCocoa 系列的第一篇文章并不会对这些问题进行详细的展开和介绍,只会对RACSignal使用过程的原理进行简单的分析。

这一小节会对RACStream以及RACSignal中与RACStream相关的部分进行简单的介绍。

RACStream

RACStream作为抽象类本身不提供方法的实现,其实现内部原生提供的而方法都是抽象方法,会在调用时直接抛出异常:

+ (__kindof RACStream *)empty {
    NSString *reason = [NSString stringWithFormat:@"%@ must be overridden by subclasses",NSStringFromSelector(_cmd)];
    @throw [NSException exceptionWithName:NSInternalInconsistencyException reason:reason userInfo:nil];
}

- (__kindof RACStream *)bind:(RACStreamBindBlock (^)(void))block;
+ (__kindof RACStream *)return:(id)value;
- (__kindof RACStream *)concat:(RACStream *)stream;
- (__kindof RACStream *)zipWith:(RACStream *)stream;
RACStream-AbstractMethod

上面的这些抽象方法都需要子类覆写,不过RACStreamOperations分类中使用上面的抽象方法提供了丰富的内容,比如说-flattenMap:方法

- (__kindof RACStream *)flattenMap:(__kindof RACStream * (^)(id value))block {
    Class class = self.class;

    return [[self bind:^{
        return ^(id value,210)">BOOL *stop) {
            id stream = block(value) ?: [class empty];
            NSCAssert([stream isKindOfClass:RACStream.class],@"Value returned from -flattenMap: is not a stream: %@",stream);

            return stream;
        };
    }] setNameWithFormat:@"[%@] -flattenMap:",self.name];
}

其他方法比如-skip:-take:-ignore:等等实例方法都构建在这些抽象方法之上,只要子类覆写了所有抽象方法就能自动获得所有的Operation分类中的方法

RACStream-Operation

RACSignal 与 Monad

如果你对 Monad 有所了解,那么你应该知道bindreturn其实是 Monad 中的概念,但 Monad 并不是本篇文章所覆盖的内容,并不会具体解释它到底是什么。

ReactiveCocoa 框架中借鉴了很多其他平台甚至语言中的概念,包括微软中的 Reactive Extension 以及 Haskell 中的 Monad,RACStream提供的抽象方法中的+return:-bind:就与 Haskell 中 Monad 完全一样。

很多人都说 Monad 只是一个自函子范畴上的一个幺半群而已;在笔者看来这种说法虽然是正确的,不过也很扯淡,这句话解释了还是跟没解释一样,如果有人再跟你用这句话解释 Monad,我觉得你最好的回应就是买一本范畴论糊他一脸。如果真的想了解 Haskell 中的 Monad 到底是什么?可以从代码的角度入手,多写一些代码就明白了,这个概念理解起来其实根本没什么困难的,当然也可以看一下A Fistful of Monads,写写其中的代码,会对 Monad 有自己的认知,当然,请不要再写一篇解释 Monad 的教程了(手动微笑)。

首先来看一下+return方法实现

+ (RACSignal *)id)value {
    return [RACReturnSignal return:value];
}

方法接受一个NSObject对象,并返回一个RACSignal的实例,它会将一个 UIKit 世界的对象NSObject转换成 ReactiveCocoa 中的RACSignal

RACSignal-Return

RACReturnSignal也仅仅是把NSObject对象包装一下,并没有做什么复杂的事情:

id)value {
    RACReturnSignal *signal = [[self alloc] init];
    signal->_value = value;
    return signal;
}

但是-bind:方法实现相比之下就十分复杂了:

- (RACSignal *)bind:(RACSignalBindBlock (^)(void))block {
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        RACSignalBindBlock bindingBlock = block();
        return [self subscribeNext:^(id x) {
            BOOL stop = NO;
            id signal = bindingBlock(x,&stop);

            if (signal != nil) {
                [signal subscribeNext:^(id x) {
                    [subscriber sendNext:x];
                } error:^(NSError *error) {
                    [subscriber sendError:error];
                } completed:^{
                    [subscriber sendCompleted];
                }];
            }
            if (signal == nil || stop) {
                [subscriber sendCompleted];
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            [subscriber sendCompleted];
        }];
    }] setNameWithFormat:@"[%@] -bind:",0)">self.name];
}

笔者在这里对-bind:方法进行了大量的省略,省去了其中对各种RACDisposable的处理过程。

-bind:方法会在原信号每次发出消息时,都执行RACSignalBindBlock对原有的信号中的消息进行变换生成一个新的信号:

RACSignal-Bind

在原有的RACSignal对象上调用-bind:方法传入RACSignalBindBlock,图示中的右侧就是具体的执行过程,原信号在变换之后变成了新的蓝色的RACSignal对象。

RACSignalBindBlock可以简单理解为一个接受NSObject对象返回RACSignal对象的函数

typedef RACSignal * _Nullable (^RACSignalBindBlock)(id _Nullable value,210)">BOOL *stop);

函数签名可以理解为id -> RACSignal,然而这种函数是无法直接对RACSignal对象进行变换的;不过通过-bind:方法就可以使用这种函数操作RACSignal,其实现如下:

  1. RACSignal对象『解包』出NSObject对象;
  2. NSObject传入RACSignalBindBlock返回RACSignal

如果在不考虑RACSignal会发出错误或者完成信号时,-bind:可以简化为更简单的形式:

BOOL stop = NO;
            [bindingBlock(x,&stop) subscribeNext:^(id x) {
                [subscriber sendNext:x];
            }];
        }];
    }] setNameWithFormat: 调用-subscribeNext:方法订阅当前信号,将信号中的状态解包,然后将原信号中的状态传入bindingBlock中并订阅返回的新的信号,将生成的新状态x传回原信号的订阅者。

这里通过两个简单的例子来了解-bind:方法的作用:

2];
    [subscriber sendNext:@3];
    [subscriber sendNext:@4];
    [subscriber sendCompleted];
    return nil;
}];
RACSignal *bindSignal = [signal bind:^RACSignalBindBlock _Nonnull{
    return ^(NSNumber *value,210)">BOOL *stop) {
        value = @(value.integerValue * value.integerValue);
        return [RACSignal return:value];
    };
}];
[signal subscribeNext:^(@"signal: %@",x);
}];
[bindSignal subscribeNext:^(@"bindSignal: %@",47); font-size:16px"> 上面的代码中直接使用了+return:方法value打包成了RACSignal *对象:

Before-After-Bind-RACSigna

在 BindSignal 中的每一个数字其实都是由一个RACSignal包裹的,这里没有画出,在下一个例子中,读者可以清晰地看到其中的区别。

上图简要展示了变化前后的信号中包含的状态,在运行上述代码时,会在终端中打印出:

signal: 1
signal: 2
signal: 3
signal: 4
bindSignal: 1
bindSignal: 9
bindSignal: 16

这是一个最简单的例子,直接使用-return:打包NSObject返回一个RACSignal,接下来用一个更复杂的例子来帮助我们更好的了解-bind:方法

BOOL *stop) {
        NSNumber *returnValue = @(value.integerValue * value.integerValue);
        return [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
            for (NSInteger i = 0; i < value.integerValue; i++) [subscriber sendNext:returnValue];
            [subscriber sendCompleted];
            return nil;
        }];
    };
}];
[bindSignal subscribeNext:^( 下图相比上面例子中的图片更能精确的表现出-bind:方法都做了什么:

Before-After-Bind-RACSignal-Complicated

信号中原有的状态经过-bind:方法中传入RACSignalBindBlock的处理实际上返回了多个RACSignal

在源代码的注释中清楚地写出了方法的实现过程:

  1. 订阅原信号中的值;
  2. 将原信号发出的值传入RACSignalBindBlock进行转换;
  3. 如果RACSignalBindBlock返回一个信号,就会订阅该信号并将信号中的所有值传给订阅subscriber
  4. 如果RACSignalBindBlock请求终止信号就会向信号发出-sendCompleted消息;
  5. 所有信号都完成时,会向订阅者发送-sendCompleted
  6. 无论何时,如果信号发出错误,都会向订阅者发送-sendError:消息。

如果想要了解-bind:方法在执行的过程中是如何处理订阅的清理和销毁的,可以阅读文章最后的-bind: 中对订阅的销毁部分。

信号的创建

信号的创建过程十分简单,-createSignal:是推荐的创建信号的方法方法其实只做了一次转发:

+ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe {
    return [RACDynamicSignal createSignal:didSubscribe];
}

+ (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe {
    RACDynamicSignal *signal = [[self alloc] init];
    signal->_didSubscribe = [didSubscribe copy];
    return [signal setNameWithFormat:@"+createSignal:"];
}

方法其实只是创建了一个RACDynamicSignal实例并保存了传入的didSubscribe代码块,在每次有订阅订阅当前信号时,都会执行一遍,向订阅者发送消息。

RACSignal 类簇

虽然-createSignal:方法签名上返回的是RACSignal对象的实例,但是实际上这里返回的是RACDynamicSignal,也就是RACSignal的子类;同样,在 ReactiveCocoa 中也有很多其他的RACSignal子类。

使用类簇的方式设计的RACSignal在创建实例时可能会返回RACDynamicSignalRACEmptySignalRACErrorSignalRACReturnSignal对象:

RACSignal-Subclasses

其实这几种子类并没有对原有的RACSignal做出太大的改变,它们的创建过程也不是特别的复杂,只需要调用RACSignal不同的类方法

RACSignal-Instantiate-Object

RACSignal只是起到了一个代理的作用,最后的实现过程还是会指向对应的子类:

+ (RACSignal *)error:(NSError *)error {
    return [RACErrorSignal error:error];
}

+ (RACSignal *)empty {
    return [RACEmptySignal empty];
}

+ (RACSignal *)RACReturnSignal的创建过程为例:

 这个信号的创建过程和RACDynamicSignal的初始化过程一样,都非常简单;只是将传入的value简单保存一下,在有其他订阅-subscribe:时,向订阅者发送value

- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
    return [RACScheduler.subscriptionScheduler schedule:^{
        [subscriber sendNext:self.value];
        [subscriber sendCompleted];
    }];
}

RACEmptySignal和RACErrorSignal的创建过程也异常的简单,只是对传入的数据进行简单的存储,然后在订阅时发送出来:

// RACEmptySignal
+ (RACSignal *)empty {
    return [[[self alloc] init] setNameWithFormat:@"+empty"];
}

- (RACDisposable *)subscribe:(return [RACScheduler.subscriptionScheduler schedule:^{
        [subscriber sendCompleted];
    }];
}

// RACErrorSignal
+ (RACSignal *)error:(NSError *)error {
    RACErrorSignal *signal = [[self alloc] init];
    signal->_error = error;
    return signal;
}

- (RACDisposable *)subscribe:(return [RACScheduler.subscriptionScheduler schedule:^{
        [subscriber sendError:self.error];
    }];
}

这两个创建过程的唯一区别就是一个发送的是『空值』,另一个是NSError对象。

信号的订阅与信息的发送

ReactiveCocoa 中信号的订阅与信息的发送过程主要是由RACSubscriber类来处理的,而这也是信号的处理过程中最重要的一部分,这一小节会先分析整个工作流程,之后会深入代码的实现。

RACSignal-Subcribe-Process

在信号创建之后调用-subscribeNext:方法返回一个RACDisposable,然而这不是这一流程关心的重点,在订阅过程中生成了一个RACSubscriber对象,向这个对象发送消息-sendNext:时,就会向所有的订阅者发送消息。

信号的订阅

信号的订阅-subscribe:开头的一系列方法有关:

RACSignal-Subscribe-Methods

订阅者可以选择自己想要感兴趣的信息类型next/error/completed进行关注,并在对应的信息发生时调用 block 进行处理回调。

所有的方法其实只是对nextBlockcompletedBlock以及errorBlock的组合,这里以其中最长的-subscribeNext:error:completed:方法的实现为例(也只需要介绍这一个方法):

- (RACDisposable *)subscribeNext:(void (^)(id x))nextBlock error:(void (^)(NSError *error))errorBlock completed:(void))completedBlock {
    RACSubscriber *o = [RACSubscriber subscriberWithNext:nextBlock error:errorBlock completed:completedBlock];
    self subscribe:o];
}

方法中传入的所有 block 参数都应该是非空的。

拿到了传入的 block 之后,使用+subscriberWithNext:error:completed:初始化一个RACSubscriber对象的实例:

+ (instancetype)subscriberWithNext:(id x))next error:(NSError *error))error completed:(void))completed {
    RACSubscriber *subscriber = [[self alloc] init];

    subscriber->_next = [next copy];
    subscriber->_error = [error copy];
    subscriber->_completed = [completed copy];

    return subscriber;
}

在拿到这个对象之后,调用RACSignal-subscribe:方法传入订阅者对象:

id<RACSubscriber>)subscriber {
    NSCAssert(NO,152)">@"This method must be overridden by subclasses");
    return nil;
}

RACSignal类中其实并没有实现这个实例方法,需要在上文提到的四个子类对这个方法进行覆写,这里仅分析RACDynamicSignal中的方法

id<RACSubscriber>)subscriber {
    RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
    subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable];

    RACDisposable *schedulingDisposable = [RACScheduler.subscriptionScheduler schedule:^{
        RACDisposable *innerDisposable = self.didSubscribe(subscriber);
        [disposable addDisposable:innerDisposable];
    }];

    [disposable addDisposable:schedulingDisposable];

    return disposable;
}

这里暂时不需要关注与RACDisposable有关的任何内容,我们会在下一节中详细介绍。

RACPassthroughSubscriber就像它的名字一样,只是对上面创建的订阅者对象进行简单的包装,将所有的消息转发给内部的innerSubscriber,也就是传入的RACSubscriber对象:

- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable {
    self = [super init];

    _innerSubscriber = subscriber;
    _signal = signal;
    _disposable = disposable;

    [self.innerSubscriber didSubscribeWithDisposable:self.disposable];
    return self;
}

如果直接简化-subscribe:方法的实现,你可以看到一个看起来极为敷衍的代码

self.didSubscribe(subscriber);
}

方法只是执行了在创建信号时传入的RACSignalBindBlock

[RACSignal createSignal:^RACDisposable * _Nullable(@"dispose");
    }];
}];

总而言之,信号的订阅过程就是初始化RACSubscriber对象,然后执行didSubscribe代码块的过程。

Principle-of-Subscribing-Signals

信息的发送

RACSignalBindBlock中,订阅者可以根据自己的兴趣选择自己想要订阅哪种消息;我们也可以按需发送三种消息:

RACSignal-Subcription-Messages-Sending

而现在只需要简单看一下这三个方法的实现,就能够明白信息的发送过程了(真是没啥好说的,不过为了凑字数完整性):

void)sendNext:(@synchronized (self) {
        void (^nextBlock)(id) = [self.next copy];
        if (nextBlock == nil) return;

        nextBlock(value);
    }
}

-sendNext:只是将方法传入的值传入nextBlock调用一次,并没有什么值得去分析的地方,而剩下的两个方法实现也差不多,会调用对应的 block,在这里就省略了。

订阅的回收过程

在创建信号时,我们向-createSignal:方法中传入了didSubscribe信号,这个 block 在执行结束时会返回一个RACDisposable对象,用于在订阅结束时进行必要的清理,同样也可以用于取消因为订阅创建的正在执行的任务。

而处理这些事情的核心类就是RACDisposable以及它的子类:

RACDisposable-And-Subclasses

这篇文章中主要关注的是左侧的三个子类,当然RACDisposable的子类不止这三个,还有用于处理 KVO 的RACKVOTrampoline,不过在这里我们不会讨论这个类的实现。

RACDisposable

在继续分析讨论订阅的回收过程之前,笔者想先对RACDisposable进行简要的剖析和介绍:

RACDisposable

RACDisposable是以_disposeBlock为核心进行组织的,几乎所有的方法以及属性其实都是对_disposeBlock进行的操作。

关于 _disposeBlock 中的 self

这一小节的内容是可选的,跳过不影响整篇文章阅读的连贯性。

_disposeBlock是一个私有的指针变量,当void (^)(void)类型的 block 被传入之后都会转换成 CoreFoundation 中的类型并以void *的形式存入_disposeBlock中:

instancetype)disposableWithBlock:(self alloc] initWithBlock:block];
}

- (instancetype)initWithBlock:(super init];

    _disposeBlock = (void *)CFBridgingRetain([block copy]); 
    OSMemoryBarrier();

     奇怪的是,_disposeBlock中不止会存储代码块 block,还有可能存储桥接之后的self

instancetype)init {
    super init];

    _disposeBlock = (__bridge void *)self;
    OSMemoryBarrier();

     这里,刚开始看到可能会觉得比较奇怪,有两个疑问需要解决

  1. 为什么要提供一个-init方法来初始化RACDisposable对象?
  2. 为什么要向_disposeBlock中传入当前对象?

对于RACDisposable来说,虽然一个不包含_disposeBlock的对象没什么太多的意义,但是对于RACSerialDisposable等子类来说,却不完全是这样,因为RACSerialDisposable-dispose时,并不需要执行disposeBlock,这样就浪费了内存和 cpu 时间;但是同时我们需要一个合理的方法准确地判断当前对象的isDisposed

- (BOOL)isDisposed {
    return _disposeBlock == NULL;
}

所以,使用向_disposeBlock中传入NULL的方式来判断isDisposed;在-init调用时传入self而不是NULL防止状态被误判,这样就在不引入其他实例变量、增加对象的设计复杂度的同时,解决了这两个问题。

如果仍然不理解上述的两个问题,在这里举一个错误的例子,如果_disposeBlock在使用时只传入NULL或者block,那么在RACCompoundDisposable初始化时,是应该向_disposeBlock中传入什么呢?

  • 传入NULL会导致在初始化之后isDisposed == YES,然而当前对象根本没有被回收;
  • 传入block会导致无用的 block 的执行,浪费内存以及 cpu 时间;

这也就是为什么要引入self来作为_disposeBlock内容的原因。

-dispose: 方法的实现

这个只有不到 20 行的-dispose:方法已经是整个RACDisposable类中最复杂的方法了:

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

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

            break;
        }
    }

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

但是其实它的实现也没有复杂到哪里去,从_disposeBlock实例变量中调用CFBridgingRelease取出一个disposeBlock,然后执行这个 block,整个方法就结束了。

RACSerialDisposable

RACSerialDisposable是一个用于持有RACDisposable的容器,它一次只能持有一个RACDisposable的实例,并可以原子地换出容器中保存的对象:

- (RACDisposable *)swapInDisposable:(RACDisposable *)newDisposable {
    RACDisposable *existingDisposable;
    BOOL alreadyDisposed;

    pthread_mutex_lock(&_mutex);
    alreadyDisposed = _disposed;
    if (!alreadyDisposed) {
        existingDisposable = _disposable;
        _disposable = newDisposable;
    }
    pthread_mutex_unlock(&_mutex);

    if (alreadyDisposed) {
        [newDisposable dispose];
        return nil;
    }

    return existingDisposable;
}

线程安全的RACSerialDisposable使用pthred_mutex_t互斥锁来保证在访问关键变量时不会出现线程竞争问题。

-dispose方法的处理也十分简单:

void)dispose {
    RACDisposable *existingDisposable;

    pthread_mutex_lock(&_mutex);
    if (!_disposed) {
        existingDisposable = _disposable;
        _disposed = YES;
        _disposable = nil;
    }
    pthread_mutex_unlock(&_mutex);

    [existingDisposable dispose];
}

使用锁保证线程安全,并在内部的_disposable换出之后在执行-dispose方法订阅进行处理。

RACCompoundDisposable

RACSerialDisposable只负责一个RACDisposable对象的释放不同;RACCompoundDisposable同时负责多个RACDisposable对象的释放。

相比于只管理一个RACDisposable对象的RACSerialDisposableRACCompoundDisposable由于管理多个对象,其实现更加复杂,而且为了性能和内存占用之间的权衡,其实现方式是通过持有两个实例变量:

@interface RACCompoundDisposable () {
    ...
    RACDisposable *_inlineDisposables[RACCompoundDisposableInlineCount];

    CFMutableArrayRef _disposables;
    ...
}

在对象持有的RACDisposable不超过RACCompoundDisposableInlineCount时,都会存储在_inlineDisposables数组中,而更多的实例都会存储在_disposables中:

RACCompoundDisposable

RACCompoundDisposable在使用-initWithDisposables:初始化时,会初始化两个RACDisposable的位置用于加速销毁订阅的过程,同时为了不浪费内存空间,在默认情况下只占用两个位置:

instancetype)initWithDisposables:(NSArray *)otherDisposables {
    self init];

    [otherDisposables enumerateObjectsUsingBlock:^(RACDisposable *disposable,210)">NSUInteger index,210)">BOOL *stop) {
        self->_inlineDisposables[index] = disposable;
        if (index == RACCompoundDisposableInlineCount - 1) *stop = YES;
    }];

    if (otherDisposables.count > RACCompoundDisposableInlineCount) {
        _disposables = RACCreateDisposablesArray();

        CFRange range = CFRangeMake(RACCompoundDisposableInlineCount,(CFIndex)otherDisposables.count - RACCompoundDisposableInlineCount);
        CFArrayAppendArray(_disposables,(__bridge CFArrayRef)otherDisposables,range);
    }

     如果传入的otherDisposables多于RACCompoundDisposableInlineCount,就会创建一个新的CFMutableArrayRef引用,并将剩余的RACDisposable全部传入这个数组中。

RACCompoundDisposable中另一个值得注意的方法就是-addDisposable:

void)addDisposable:(RACDisposable *)disposable {
    if (disposable == nil || disposable.disposed) return;

    BOOL shouldDispose = NO;

    pthread_mutex_lock(&_mutex);
    {
        if (_disposed) {
            shouldDispose = YES;
        } else {
            for (unsigned i = 0; i < RACCompoundDisposableInlineCount; i++) {
                if (_inlineDisposables[i] == nil) {
                    _inlineDisposables[i] = disposable;
                    goto foundSlot;
                }
            }

            if (_disposables == NULL) _disposables = RACCreateDisposablesArray();
            CFArrayAppendValue(_disposables,(__bridge void *)disposable);
        foundSlot:;
        }
    }
    pthread_mutex_unlock(&_mutex);
    if (shouldDispose) [disposable dispose];
}

在向RACCompoundDisposable添加新的RACDisposable对象时,会先尝试在_inlineDisposables数组中寻找空闲的位置,如果没有找到,就会加入到_disposables中;但是,在添加RACDisposable的过程中也难免遇到当前RACCompoundDisposable已经dispose的情况,而这时就会直接-dispose刚刚加入的对象。

订阅的销毁过程

在了解了 ReactiveCocoa 中与订阅销毁相关的类,我们就可以继续对-bind:方法的分析了,之前在分析该方法时省略了-bind:在执行过程中是如何处理订阅的清理和销毁的,所以会省略对于正常值和错误的处理过程,首先来看一下简化后的代码

id<RACSubscriber> subscriber) {
        RACSignalBindBlock bindingBlock = block();
        __block volatile int32_t signalCount = 1;
        RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];

        void (^completeSignal)(RACDisposable *) = ...
        void (^addSignal)(RACSignal *) = ...

        RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];
        [compoundDisposable addDisposable:selfDisposable];
        RACDisposable *bindingDisposable = [if (signal != nil) addSignal(signal);
            if (signal == nil || stop) {
                [selfDisposable dispose];
                completeSignal(selfDisposable);
            }
        } completed:^{
            completeSignal(selfDisposable);
        }];
        selfDisposable.disposable = bindingDisposable;
        return compoundDisposable;
    }] setNameWithFormat: 在简化的代码中,订阅的清理是由一个RACCompoundDisposable的实例负责的,向这个实例中添加RACSerialDisposable以及RACDisposable对象,并在RACCompoundDisposable销毁时销毁。

completeSignal和addSignal两个 block 主要负责处理新创建信号的清理工作:

void (^completeSignal)(RACDisposable *) = ^(RACDisposable *finishedDisposable) {
    if (OSAtomicDecrement32Barrier(&signalCount) == 0) {
        [subscriber sendCompleted];
        [compoundDisposable dispose];
    } else {
        [compoundDisposable removeDisposable:finishedDisposable];
    }
};

void (^addSignal)(RACSignal *) = ^(RACSignal *signal) {
    OSAtomicIncrement32Barrier(&signalCount);
    RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];
    [compoundDisposable addDisposable:selfDisposable];
    RACDisposable *disposable = [signal completed:^{
        completeSignal(selfDisposable);
    }];
    selfDisposable.disposable = disposable;
};

先通过一个例子来看一下-bind:方法调用之后,订阅是如何被清理的:

@"Original Signal Dispose.");
    }];
}];
RACSignal *bindSignal = [signal bind:^RACSignalBindBlock _Nonnull{
    NSNumber *returnValue = @(value.integerValue);
        return [RACDisposable disposableWithBlock:^{
                @"Binding Signal Dispose.");
            }];
        }];
    };
}];
[bindSignal subscribeNext:^( 在每个订阅创建以及所有的值发送之后,订阅就会被就地销毁,调用disposeBlock,并从RACCompoundDisposable实例中移除:

1
Binding Signal Dispose.
2
2
Binding Signal Dispose.
Original Signal Dispose.

订阅的销毁时间以及绑定信号的控制是由SignalCount控制的,其表示RACCompoundDisposable中的RACSerialDisposable实例的个数,在每次有新的订阅被创建时都会向RACCompoundDisposable加入一个新的RACSerialDisposable,并在订阅发送结束时从数组中移除,整个过程用图示来表示比较清晰:

RACSignal-Bind-Disposable

紫色的RACSerialDisposable为原订阅创建的对象,灰色的为新信号订阅的对象。

总结

这是整个 ReactiveCocoa 源代码分析系列文章的第一篇,想写一个跟这个系列有关的代码已经很久了,文章中对于RACSignal进行了一些简单的介绍,项目中绝大多数的方法都是很简洁的,行数并不多,代码的组织方式也很易于理解。虽然没有太多让人意外的东西,不过整个工程还是很值得阅读的。

References

方法实现对照表

方法 实现
+return: RACSignal.m#L89-L91
-bind: RACSignal.m#L93-176

Github Repo:iOS-Source-Code-Analyze

Follow:Draveness · GitHub

Source:http://draveness.me/racsignal




转自:http://www.jianshu.com/p/4e14ee63a12b

猜你在找的React相关文章