ReactiveCocoa 中 RACSignal 是如何發送信號的

前言

ReactiveCocoa是一個(第一個？)將函數響應式編程范例帶入Objective-C的開源庫。ReactiveCocoa是由Josh Abernathy和Justin Spahr-Summers 兩位大神在對GitHub for Mac的開發過程中編寫的。Justin Spahr-Summers 大神在2011年11月13號下午12點35分進行的第一次提交，直到2013年2月13日上午3點05分發布了其1.0 release，達到了第一個重要里程碑。ReactiveCocoa社區也非常活躍，目前最新版已經完成了ReactiveCocoa 5.0.0-alpha.3，目前在5.0.0-alpha.4開發中。

ReactiveCocoa v2.5 是公認的Objective-C最穩定的版本，因此被廣大的以OC為主要語言的客戶端選中使用。ReactiveCocoa v3.x主要是基于Swift 1.2的版本，而ReactiveCocoa v4.x 主要基于Swift 2.x，ReactiveCocoa 5.0就全面支持Swift 3.0，也許還有以后的Swift 4.0。接下來幾篇博客先以ReactiveCocoa v2.5版本為例子，分析一下OC版的RAC具體實現（也許分析完了RAC 5.0就到來了）。也算是寫在ReactiveCocoa 5.0正式版到來前夕的祝福吧。

一. 什么是ReactiveCocoa？

ReactiveCocoa（其簡稱為RAC）是由Github 開源的一個應用于iOS和OS X開發的新框架。RAC具有函數式編程(FP)和響應式編程(RP)的特性。它主要吸取了.Net的 Reactive Extensions的設計和實現。

ReactiveCocoa 的宗旨是Streams of values over time ，隨著時間變化而不斷流動的數據流。

ReactiveCocoa 主要解決了以下這些問題：

UI數據綁定

UI控件通常需要綁定一個事件，RAC可以很方便的綁定任何數據流到控件上。

用戶交互事件綁定

RAC為可交互的UI控件提供了一系列能發送Signal信號的方法。這些數據流會在用戶交互中相互傳遞。

解決狀態以及狀態之間依賴過多的問題

有了RAC的綁定之后，可以不用在關心各種復雜的狀態，isSelect，isFinish……也解決了這些狀態在后期很難維護的問題。

消息傳遞機制的大統一

OC中編程原來消息傳遞機制有以下幾種：Delegate，Block Callback，Target-Action，Timers，KVO，objc上有一篇關于OC中這5種消息傳遞方式改如何選擇的文章Communication Patterns，推薦大家閱讀。現在有了RAC之后，以上這5種方式都可以統一用RAC來處理。

二. RAC中的核心RACSignal

ReactiveCocoa 中最核心的概念之一就是信號RACStream。RACStream中有兩個子類——RACSignal 和 RACSequence。本文先來分析RACSignal。

我們會經常看到以下的代碼：


RACSignal *signal = [RACSignal createSignal:
                     ^RACDisposable *(id<RACSubscriber> subscriber)
{
    [subscriber sendNext:@1];
    [subscriber sendNext:@2];
    [subscriber sendNext:@3];
    [subscriber sendCompleted];
    return [RACDisposable disposableWithBlock:^{
        NSLog(@"signal dispose");
    }];
}];
RACDisposable *disposable = [signal subscribeNext:^(id x) {
    NSLog(@"subscribe value = %@", x);
} error:^(NSError *error) {
    NSLog(@"error: %@", error);
} completed:^{
    NSLog(@"completed");
}];

[disposable dispose];

這是一個RACSignal被訂閱的完整過程。被訂閱的過程中，究竟發生了什么？


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

RACSignal調用createSignal的時候，會調用RACDynamicSignal的createSignal的方法。

RACDynamicSignal是RACSignal的子類。createSignal后面的參數是一個block。


(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe

block的返回值是RACDisposable類型，block名叫didSubscribe。block的唯一一個參數是id<RACSubscriber>類型的subscriber，這個subscriber是必須遵循RACSubscriber協議的。

RACSubscriber是一個協議，其下有以下4個協議方法：


@protocol RACSubscriber <NSObject>
@required

- (void)sendNext:(id)value;
- (void)sendError:(NSError *)error;
- (void)sendCompleted;
- (void)didSubscribeWithDisposable:(RACCompoundDisposable *)disposable;

@end

所以新建Signal的任務就全部落在了RACSignal的子類RACDynamicSignal上了。



@interface RACDynamicSignal ()
// The block to invoke for each subscriber.
@property (nonatomic, copy, readonly) RACDisposable * (^didSubscribe)(id<RACSubscriber> subscriber);
@end

RACDynamicSignal這個類很簡單，里面就保存了一個名字叫didSubscribe的block。



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

這個方法中新建了一個RACDynamicSignal對象signal，并把傳進來的didSubscribe這個block保存進剛剛新建對象signal里面的didSubscribe屬性中。最后再給signal命名+createSignal:。


- (instancetype)setNameWithFormat:(NSString *)format, ... {
 if (getenv("RAC_DEBUG_SIGNAL_NAMES") == NULL) return self;

   NSCParameterAssert(format != nil);

   va_list args;
   va_start(args, format);

   NSString *str = [[NSString alloc] initWithFormat:format arguments:args];
   va_end(args);

   self.name = str;
   return self;
}

setNameWithFormat是RACStream里面的方法，由于RACDynamicSignal繼承自RACSignal，所以它也能調用這個方法。

RACSignal的block就這樣被保存起來了，那什么時候會被執行呢？

block閉包在訂閱的時候才會被“釋放”出來。

RACSignal調用subscribeNext方法，返回一個RACDisposable。


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

在這個方法中會新建一個RACSubscriber對象，并傳入nextBlock，errorBlock，completedBlock。


@interface RACSubscriber ()

// These callbacks should only be accessed while synchronized on self.
@property (nonatomic, copy) void (^next)(id value);
@property (nonatomic, copy) void (^error)(NSError *error);
@property (nonatomic, copy) void (^completed)(void);
@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable;

@end

RACSubscriber這個類很簡單，里面只有4個屬性，分別是nextBlock，errorBlock，completedBlock和一個RACCompoundDisposable信號。


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

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

   return subscriber;
}

subscriberWithNext方法把傳入的3個block都保存分別保存到自己對應的block中。

RACSignal調用subscribeNext方法，最后return的時候，會調用[self subscribe:o]，這里實際是調用了RACDynamicSignal類里面的subscribe方法。



- (RACDisposable *)subscribe:(id<RACSubscriber>)subscriber {
 NSCParameterAssert(subscriber != nil);

   RACCompoundDisposable *disposable = [RACCompoundDisposable compoundDisposable];
   subscriber = [[RACPassthroughSubscriber alloc] initWithSubscriber:subscriber signal:self disposable:disposable];

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

    [disposable addDisposable:schedulingDisposable];
 }
 
 return disposable;
}

RACDisposable有3個子類，其中一個就是RACCompoundDisposable。



@interface RACCompoundDisposable : RACDisposable
+ (instancetype)compoundDisposable;
+ (instancetype)compoundDisposableWithDisposables:(NSArray *)disposables;
- (void)addDisposable:(RACDisposable *)disposable;
- (void)removeDisposable:(RACDisposable *)disposable;
@end

RACCompoundDisposable雖然是RACDisposable的子類，但是它里面可以加入多個RACDisposable對象，在必要的時候可以一口氣都調用dispose方法來銷毀信號。當RACCompoundDisposable對象被dispose的時候，也會自動dispose容器內的所有RACDisposable對象。

RACPassthroughSubscriber是一個私有的類。


@interface RACPassthroughSubscriber : NSObject <RACSubscriber>
@property (nonatomic, strong, readonly) id<RACSubscriber> innerSubscriber;
@property (nonatomic, unsafe_unretained, readonly) RACSignal *signal;
@property (nonatomic, strong, readonly) RACCompoundDisposable *disposable;
- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable;
@end

RACPassthroughSubscriber類就只有這一個方法。目的就是為了把所有的信號事件從一個訂閱者subscriber傳遞給另一個還沒有disposed的訂閱者subscriber。

RACPassthroughSubscriber類中保存了3個非常重要的對象，RACSubscriber，RACSignal，RACCompoundDisposable。RACSubscriber是待轉發的信號的訂閱者subscriber。RACCompoundDisposable是訂閱者的銷毀對象，一旦它被disposed了，innerSubscriber就再也接受不到事件流了。

這里需要注意的是內部還保存了一個RACSignal，并且它的屬性是unsafe_unretained。這里和其他兩個屬性有區別，其他兩個屬性都是strong的。這里之所以不是weak，是因為引用RACSignal僅僅只是一個DTrace probes動態跟蹤技術的探針。如果設置成weak，會造成沒必要的性能損失。所以這里僅僅是unsafe_unretained就夠了。


- (instancetype)initWithSubscriber:(id<RACSubscriber>)subscriber signal:(RACSignal *)signal disposable:(RACCompoundDisposable *)disposable {
   NSCParameterAssert(subscriber != nil);

   self = [super init];
   if (self == nil) return nil;

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

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

回到RACDynamicSignal類里面的subscribe方法中，現在新建好了RACCompoundDisposable和RACPassthroughSubscriber對象了。


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

  [disposable addDisposable:schedulingDisposable];
 }

RACScheduler.subscriptionScheduler是一個全局的單例。



+ (instancetype)subscriptionScheduler {
   static dispatch_once_t onceToken;
   static RACScheduler *subscriptionScheduler;
   dispatch_once(&onceToken, ^{
    subscriptionScheduler = [[RACSubscriptionScheduler alloc] init];
   });

   return subscriptionScheduler;
}

RACScheduler再繼續調用schedule方法。



- (RACDisposable *)schedule:(void (^)(void))block {
   NSCParameterAssert(block != NULL);
   if (RACScheduler.currentScheduler == nil) return [self.backgroundScheduler schedule:block];
   block();
   return nil;
}



+ (BOOL)isOnMainThread {
 return [NSOperationQueue.currentQueue isEqual:NSOperationQueue.mainQueue] || [NSThread isMainThread];
}

+ (instancetype)currentScheduler {
 RACScheduler *scheduler = NSThread.currentThread.threadDictionary[RACSchedulerCurrentSchedulerKey];
 if (scheduler != nil) return scheduler;
 if ([self.class isOnMainThread]) return RACScheduler.mainThreadScheduler;

 return nil;
}

在取currentScheduler的過程中，會判斷currentScheduler是否存在，和是否在主線程中。如果都沒有，那么就會調用后臺backgroundScheduler去執行schedule。

schedule的入參就是一個block，執行schedule的時候會去執行block。也就是會去執行：


RACDisposable *innerDisposable = self.didSubscribe(subscriber);
   [disposable addDisposable:innerDisposable];

這兩句關鍵的語句。之前信號里面保存的block就會在此處被“釋放”執行。self.didSubscribe(subscriber)這一句就執行了信號保存的didSubscribe閉包。

在didSubscribe閉包中有sendNext，sendError，sendCompleted，執行這些語句會分別調用RACPassthroughSubscriber里面對應的方法。


- (void)sendNext:(id)value {
 if (self.disposable.disposed) return;
 if (RACSIGNAL_NEXT_ENABLED()) {
  RACSIGNAL_NEXT(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description), cleanedDTraceString([value description]));
 }
 [self.innerSubscriber sendNext:value];
}

- (void)sendError:(NSError *)error {
 if (self.disposable.disposed) return;
 if (RACSIGNAL_ERROR_ENABLED()) {
  RACSIGNAL_ERROR(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description), cleanedDTraceString(error.description));
 }
 [self.innerSubscriber sendError:error];
}

- (void)sendCompleted {
 if (self.disposable.disposed) return;
 if (RACSIGNAL_COMPLETED_ENABLED()) {
  RACSIGNAL_COMPLETED(cleanedSignalDescription(self.signal), cleanedDTraceString(self.innerSubscriber.description));
 }
 [self.innerSubscriber sendCompleted];
}

這個時候的訂閱者是RACPassthroughSubscriber。RACPassthroughSubscriber里面的innerSubscriber才是最終的實際訂閱者，RACPassthroughSubscriber會把值再繼續傳遞給innerSubscriber。


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

  nextBlock(value);
 }
}

- (void)sendError:(NSError *)e {
 @synchronized (self) {
  void (^errorBlock)(NSError *) = [self.error copy];
  [self.disposable dispose];

  if (errorBlock == nil) return;
  errorBlock(e);
 }
}

- (void)sendCompleted {
 @synchronized (self) {
  void (^completedBlock)(void) = [self.completed copy];
  [self.disposable dispose];

  if (completedBlock == nil) return;
  completedBlock();
 }
}

innerSubscriber是RACSubscriber，調用sendNext的時候會先把自己的self.next閉包copy一份，再調用，而且整個過程還是線程安全的，用@synchronized保護著。最終訂閱者的閉包在這里被調用。

sendError和sendCompleted也都是同理。

總結一下：

RACSignal調用subscribeNext方法，新建一個RACSubscriber。
新建的RACSubscriber會copy，nextBlock，errorBlock，completedBlock存在自己的屬性變量中。
RACSignal的子類RACDynamicSignal調用subscribe方法。
新建RACCompoundDisposable和RACPassthroughSubscriber對象。RACPassthroughSubscriber分別保存對RACSignal，RACSubscriber，RACCompoundDisposable的引用，注意對RACSignal的引用是unsafe_unretained的。
RACDynamicSignal調用didSubscribe閉包。先調用RACPassthroughSubscriber的相應的sendNext，sendError，sendCompleted方法。
RACPassthroughSubscriber再去調用self.innerSubscriber，即RACSubscriber的nextBlock，errorBlock，completedBlock。注意這里調用同樣是先copy一份，再調用閉包執行。

三. RACSignal操作的核心bind實現

在RACSignal的源碼里面包含了兩個基本操作，concat和zipWith。不過在分析這兩個操作之前，先來分析一下更加核心的一個函數，bind操作。

先來說說bind函數的作用：

會訂閱原始的信號。
任何時刻原始信號發送一個值，都會綁定的block轉換一次。
一旦綁定的block轉換了值變成信號，就立即訂閱，并把值發給訂閱者subscriber。
一旦綁定的block要終止綁定，原始的信號就complete。
當所有的信號都complete，發送completed信號給訂閱者subscriber。
如果中途信號出現了任何error，都要把這個錯誤發送給subscriber


- (RACSignal *)bind:(RACStreamBindBlock (^)(void))block {
 NSCParameterAssert(block != NULL);

 return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
  RACStreamBindBlock bindingBlock = block();

  NSMutableArray *signals = [NSMutableArray arrayWithObject:self];

  RACCompoundDisposable *compoundDisposable = [RACCompoundDisposable compoundDisposable];

  void (^completeSignal)(RACSignal *, RACDisposable *) = ^(RACSignal *signal, RACDisposable *finishedDisposable) { /*這里暫時省略*/ };
  void (^addSignal)(RACSignal *) = ^(RACSignal *signal) { /*這里暫時省略*/ };

  @autoreleasepool {
   RACSerialDisposable *selfDisposable = [[RACSerialDisposable alloc] init];
   [compoundDisposable addDisposable:selfDisposable];

   RACDisposable *bindingDisposable = [self subscribeNext:^(id x) {
    // Manually check disposal to handle synchronous errors.
    if (compoundDisposable.disposed) return;

    BOOL stop = NO;
    id signal = bindingBlock(x, &stop);

    @autoreleasepool {
     if (signal != nil) addSignal(signal);
     if (signal == nil || stop) {
      [selfDisposable dispose];
      completeSignal(self, selfDisposable);
     }
    }
   } error:^(NSError *error) {
    [compoundDisposable dispose];
    [subscriber sendError:error];
   } completed:^{
    @autoreleasepool {
     completeSignal(self, selfDisposable);
    }
   }];

   selfDisposable.disposable = bindingDisposable;
  }

  return compoundDisposable;
 }] setNameWithFormat:@"[%@] -bind:", self.name];
}

為了弄清楚bind函數究竟做了什么，寫出測試代碼：


    RACSignal *signal = [RACSignal createSignal:
                         ^RACDisposable *(id<RACSubscriber> subscriber)
    {
        [subscriber sendNext:@1];
        [subscriber sendNext:@2];
        [subscriber sendNext:@3];
        [subscriber sendCompleted];
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"signal dispose");
        }];
    }];
    
    RACSignal *bindSignal = [signal bind:^RACStreamBindBlock{
        return ^RACSignal *(NSNumber *value, BOOL *stop){
            value = @(value.integerValue * 2);
            return [RACSignal return:value];
        };
    }];
    
    [bindSignal subscribeNext:^(id x) {
        NSLog(@"subscribe value = %@", x);
    }];

由于前面第一章節詳細講解了RACSignal的創建和訂閱的全過程，這個也為了方法講解，創建RACDynamicSignal，RACCompoundDisposable，RACPassthroughSubscriber這些都略過，這里著重分析一下bind的各個閉包傳遞創建和訂閱的過程。

為了防止接下來的分析會讓讀者看暈，這里先把要用到的block進行編號。


    RACSignal *signal = [RACSignal createSignal:
                         ^RACDisposable *(id<RACSubscriber> subscriber)
    {
        // block 1
    }

    RACSignal *bindSignal = [signal bind:^RACStreamBindBlock{
        // block 2
        return ^RACSignal *(NSNumber *value, BOOL *stop){
            // block 3
        };
    }];

    [bindSignal subscribeNext:^(id x) {
        // block 4
    }];

- (RACSignal *)bind:(RACStreamBindBlock (^)(void))block {
        // block 5
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        // block 6
        RACStreamBindBlock bindingBlock = block();
        NSMutableArray *signals = [NSMutableArray arrayWithObject:self];
        
        void (^completeSignal)(RACSignal *, RACDisposable *) = ^(RACSignal *signal, RACDisposable *finishedDisposable) {
        // block 7
        };
        
        void (^addSignal)(RACSignal *) = ^(RACSignal *signal) {
        // block 8
            RACDisposable *disposable = [signal subscribeNext:^(id x) {
            // block 9
            }];
        };
        
        @autoreleasepool {
            RACDisposable *bindingDisposable = [self subscribeNext:^(id x) {
                // block 10
                id signal = bindingBlock(x, &stop);
                
                @autoreleasepool {
                    if (signal != nil) addSignal(signal);
                    if (signal == nil || stop) {
                        [selfDisposable dispose];
                        completeSignal(self, selfDisposable);
                    }
                }
            } error:^(NSError *error) {
                [compoundDisposable dispose];
                [subscriber sendError:error];
            } completed:^{
                @autoreleasepool {
                    completeSignal(self, selfDisposable);
                }
            }];
        }
        return compoundDisposable;
    }] ;
}

先創建信號signal，didSubscribe把block1 copy保存起來。

當信號調用bind進行綁定，會調用block5，didSubscribe把block6 copy保存起來。

當訂閱者開始訂閱bindSignal的時候，流程如下：

bindSignal執行didSubscribe的block，即執行block6。
在block6 的第一句代碼，就是調用RACStreamBindBlock bindingBlock = block()，這里的block是外面傳進來的block2，于是開始調用block2。執行完block2，會返回一個RACStreamBindBlock的對象。
由于是signal調用的bind函數，所以bind函數里面的self就是signal，在bind內部訂閱了signal的信號。subscribeNext所以會執行block1。
執行block1，sendNext調用訂閱者subscriber的nextBlock，于是開始執行block10。
block10中會先調用bindingBlock，這個是之前調用block2的返回值，這個RACStreamBindBlock對象里面保存的是block3。所以開始調用block3。
在block3中入參是一個value，這個value是signal中sendNext中發出來的value的值，在block3中可以對value進行變換，變換完成后，返回一個新的信號signal'。
如果返回的signal'為空，則會調用completeSignal，即調用block7。block7中會發送sendCompleted。如果返回的signal'不為空，則會調用addSignal，即調用block8。block8中會繼續訂閱signal'。由于signal'是外面bind函數的返回值，返回值的信號是RACReturnSignal類型的，所以一訂閱就會sendNext，就會執行block9。
block9 中會sendNext，這里的subscriber是block6的入參，于是對subscriber調用sendNext，會調用到bindSignal的訂閱者的block4中。
block9 中執行完sendNext，還會調用sendCompleted。這里的是在執行block9里面的completed閉包。completeSignal(signal, selfDisposable);然后又會調用completeSignal，即block7。
執行完block7，就完成了一次從signal 發送信號sendNext的全過程。

bind整個流程就完成了。

四. RACSignal基本操作concat和zipWith實現

接下來再來分析RACSignal中另外2個基本操作。

1. concat

寫出測試代碼：



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


    RACSignal *signals = [RACSignal createSignal:
                         ^RACDisposable *(id<RACSubscriber> subscriber)
    {
        [subscriber sendNext:@2];
        [subscriber sendNext:@3];
        [subscriber sendNext:@6];
        [subscriber sendCompleted];
        return [RACDisposable disposableWithBlock:^{
            NSLog(@"signal dispose");
        }];
    }];

    RACSignal *concatSignal = [signal concat:signals];
    
    [concatSignal subscribeNext:^(id x) {
        NSLog(@"subscribe value = %@", x);
    }];

concat操作就是把兩個信號合并起來。注意合并有先后順序。


- (RACSignal *)concat:(RACSignal *)signal {
   return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
    RACSerialDisposable *serialDisposable = [[RACSerialDisposable alloc] init];

    RACDisposable *sourceDisposable = [self subscribeNext:^(id x) {
     // 發送第一個信號的值
     [subscriber sendNext:x];
    } error:^(NSError *error) {
     [subscriber sendError:error];
    } completed:^{
     // 訂閱第二個信號
     RACDisposable *concattedDisposable = [signal subscribe:subscriber];
     serialDisposable.disposable = concattedDisposable;
  }];

    serialDisposable.disposable = sourceDisposable;
    return serialDisposable;
 }] setNameWithFormat:@"[%@] -concat: %@", self.name, signal];
}

合并前，signal和signals分別都把各自的didSubscribe保存copy起來。
合并之后，合并之后新的信號的didSubscribe會把block保存copy起來。

當合并之后的信號被訂閱的時候：

調用新的合并信號的didSubscribe。
由于是第一個信號調用的concat方法，所以block中的self是前一個信號signal。合并信號的didSubscribe會先訂閱signal。
由于訂閱了signal，于是開始執行signal的didSubscribe，sendNext，sendError。
當前一個信號signal發送sendCompleted之后，就會開始訂閱后一個信號signals，調用signals的didSubscribe。
由于訂閱了后一個信號，于是后一個信號signals開始發送sendNext，sendError，sendCompleted。

這樣兩個信號就前后有序的拼接到了一起。

這里有二點需要注意的是：

只有當第一個信號完成之后才能收到第二個信號的值，因為第二個信號是在第一個信號completed的閉包里面訂閱的，所以第一個信號不結束，第二個信號也不會被訂閱。
兩個信號concat在一起之后，新的信號的結束信號在第二個信號結束的時候才結束。看上圖描述，新的信號的發送長度等于前面兩個信號長度之和，concat之后的新信號的結束信號也就是第二個信號的結束信號。

concat是有序的組合，第一個信號完成之后才發送第二個信號。

2. zipWith

寫出測試代碼：



    RACSignal *concatSignal = [signal zipWith:signals];
    
    [concatSignal subscribeNext:^(id x) {
        NSLog(@"subscribe value = %@", x);
    }];

源碼如下：


- (RACSignal *)zipWith:(RACSignal *)signal {
    NSCParameterAssert(signal != nil);
    
    return [[RACSignal createSignal:^(id<RACSubscriber> subscriber) {
        __block BOOL selfCompleted = NO;
        NSMutableArray *selfValues = [NSMutableArray array];
        
        __block BOOL otherCompleted = NO;
        NSMutableArray *otherValues = [NSMutableArray array];
        
        void (^sendCompletedIfNecessary)(void) = ^{
            @synchronized (selfValues) {
                BOOL selfEmpty = (selfCompleted && selfValues.count == 0);
                BOOL otherEmpty = (otherCompleted && otherValues.count == 0);
                
                // 如果任意一個信號完成并且數組里面空了，就整個信號算完成
                if (selfEmpty || otherEmpty) [subscriber sendCompleted];
            }
        };
        
        void (^sendNext)(void) = ^{
            @synchronized (selfValues) {
                
                // 數組里面的空了就返回。
                if (selfValues.count == 0) return;
                if (otherValues.count == 0) return;
                
                // 每次都取出兩個數組里面的第0位的值，打包成元組
                RACTuple *tuple = RACTuplePack(selfValues[0], otherValues[0]);
                [selfValues removeObjectAtIndex:0];
                [otherValues removeObjectAtIndex:0];
                
                // 把元組發送出去
                [subscriber sendNext:tuple];
                sendCompletedIfNecessary();
            }
        };
        
        // 訂閱第一個信號
        RACDisposable *selfDisposable = [self subscribeNext:^(id x) {
            @synchronized (selfValues) {
                
                // 把第一個信號的值加入到數組中
                [selfValues addObject:x ?: RACTupleNil.tupleNil];
                sendNext();
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            @synchronized (selfValues) {
                
                // 訂閱完成時判斷是否要發送完成信號
                selfCompleted = YES;
                sendCompletedIfNecessary();
            }
        }];
        
        // 訂閱第二個信號
        RACDisposable *otherDisposable = [signal subscribeNext:^(id x) {
            @synchronized (selfValues) {
                
                // 把第二個信號加入到數組中
                [otherValues addObject:x ?: RACTupleNil.tupleNil];
                sendNext();
            }
        } error:^(NSError *error) {
            [subscriber sendError:error];
        } completed:^{
            @synchronized (selfValues) {
                
                // 訂閱完成時判斷是否要發送完成信號
                otherCompleted = YES;
                sendCompletedIfNecessary();
            }
        }];
        
        return [RACDisposable disposableWithBlock:^{
            
            // 銷毀兩個信號
            [selfDisposable dispose];
            [otherDisposable dispose];
        }];
    }] setNameWithFormat:@"[%@] -zipWith: %@", self.name, signal];
}

當把兩個信號通過zipWith之后，就像上面的那張圖一樣，拉鏈的兩邊被中間的拉索拉到了一起。既然是拉鏈，那么一一的位置是有對應的，上面的拉鏈第一個位置只能對著下面拉鏈第一個位置，這樣拉鏈才能拉到一起去。

具體實現：

zipWith里面有兩個數組，分別會存儲兩個信號的值。

一旦訂閱了zipWith之后的信號，就開始執行didSubscribe閉包。
在閉包中會先訂閱第一個信號。這里假設第一個信號比第二個信號先發出一個值。第一個信號發出來的每一個值都會被加入到第一個數組中保存起來，然后調用sendNext( )閉包。在sendNext( )閉包中，會先判斷兩個數組里面是否都為空，如果有一個數組里面是空的，就return。由于第二個信號還沒有發送值，即第二個信號的數組里面是空的，所以這里第一個值發送不出來。于是第一個信號被訂閱之后，發送的值存儲到了第一個數組里面了，沒有發出去。
第二個信號的值緊接著發出來了，第二個信號每發送一次值，也會存儲到第二個數組中，但是這個時候再調用sendNext( )閉包的時候，不會再return了，因為兩個數組里面都有值了，兩個數組的第0號位置都有一個值了。有值以后就打包成元組RACTuple發送出去。并清空兩個數組0號位置存儲的值。
以后兩個信號每次發送一個，就先存儲在數組中，只要有“配對”的另一個信號，就一起打包成元組RACTuple發送出去。從圖中也可以看出，zipWith之后的新信號，每個信號的發送時刻是等于兩個信號最晚發出信號的時刻。
新信號的完成時間，是當兩者任意一個信號完成并且數組里面為空，就算完成了。所以最后第一個信號發送的5的那個值就被丟棄了。

第一個信號依次發送的1，2，3，4的值和第二個信號依次發送的A，B，C，D的值，一一的合在了一起，就像拉鏈把他們拉在一起。由于5沒法配對，所以拉鏈也拉不上了。

五. 最后

本來這篇文章想把Map，combineLatest，flattenMap，flatten這些也一起分析了，但是后來看到RACSingnal的操作實在有點多，于是按照源碼的文件分開了，這里先把RACSignal文件里面的操作都分析完了。RACSignal文件里面的操作主要就bind，concat和zipWith三個操作。下一篇再分析分析RACSignal+Operations文件里面的所有操作。

請大家多多指教。

最后編輯于：2017.12.04 09:28:45

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 227,797評論 6贊 531
死咒
序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
沈念sama閱讀 98,179評論 3贊 414
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 175,628評論 0贊 373
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 62,642評論 1贊 309
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 71,444評論 6贊 405
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發上，一...
開封第一講書人閱讀 54,948評論 1贊 321
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 43,040評論 3贊 440
雙鴛鴦連環套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
開封第一講書人閱讀 42,185評論 0贊 287
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
沈念sama閱讀 48,717評論 1贊 333
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內容為張勛視角年9月15日...
茶點故事閱讀 40,602評論 3贊 354
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 42,794評論 1贊 369
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,316評論 5贊 358
?日本核電站爆炸內幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
茶點故事閱讀 44,045評論 3贊 347
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,418評論 0贊 26
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 35,671評論 1贊 281
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,414評論 3贊 390
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 47,750評論 2贊 370

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

ReactiveCocoa 中 RACSignal 是如何發送信號的

ReactiveCocoa 中 RACSignal 是如何發送信號的

前言

目錄

一. 什么是ReactiveCocoa？

二. RAC中的核心RACSignal

三. RACSignal操作的核心bind實現

四. RACSignal基本操作concat和zipWith實現

1. concat

2. zipWith

五. 最后

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

ReactiveCocoa 中 RACSignal 是如何發送信號的

前言

目錄

一. 什么是ReactiveCocoa？

二. RAC中的核心RACSignal

三. RACSignal操作的核心bind實現

四. RACSignal基本操作concat和zipWith實現

1. concat

2. zipWith

五. 最后

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频