在讲RACMulticastConnection之前我们先来看一个例子。

 // 1.创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        NSLog(@"请求网络数据");
        
        // 3.成功获取网络返回的数据，发送数据
        [subscriber sendNext:@"发送数据"];
        
        return nil;
    }];
    
    // 2.订阅信号
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"订阅者一 订阅信号:%@",x);
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"订阅者二 订阅信号:%@",x);
    }];
    
    [signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"订阅者三 订阅信号:%@",x);
    }];

打印结果
2017-05-31 19:12:06.220 RACDemo[1332:258342] 请求网络数据
2017-05-31 19:12:06.221 RACDemo[1332:258342] 订阅者一 订阅信号:发送数据
2017-05-31 19:12:06.221 RACDemo[1332:258342] 请求网络数据
2017-05-31 19:12:06.221 RACDemo[1332:258342] 订阅者二 订阅信号:发送数据
2017-05-31 19:12:06.221 RACDemo[1332:258342] 请求网络数据
2017-05-31 19:12:06.222 RACDemo[1332:258342] 订阅者三 订阅信号:发送数据

你发现问题了吗？
这里有一个问题，就是我们每次订阅信号的时候，它都会去请求一次网络数据。
但实际上，我们并不需要这么频繁的请求网络数据，我们只需要确保第一次拿到网络返回的数据后，在接下来的每一次订阅中，直接拿到第一次获取到的网络数据就好了。

针对这种情况，我们就可以使用 RACMulticastConnection.
不管订阅多少次信号，只会请求一次网络数据

RACMulticastConnection 使用例子

// 1. 创建信号
    RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
        NSLog(@"请求网络数据");
        // 成功获取网络返回的数据，发送数据
        [subscriber sendNext:@"发送网络数据"];
        return nil;
    }];
// 2. 把信号转换成连接类
// 这里除了用publish创建，也可以用-muticast:方法创建
    RACMulticastConnection *connection = [signal publish];
// 3. 订阅连接类的信号
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"连接类订阅者一 订阅信号:%@",x);
    }];
    
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"连接类订阅者二 订阅信号:%@",x);
    }];
    
    [connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"连接类订阅者三 订阅信号:%@",x);
    }];
// 4. 连接
    [connection connect];

打印结果：
2017-05-31 20:36:08.569 RACDemo[1645:604549] 请求网络数据
2017-05-31 20:36:08.569 RACDemo[1645:604549] 连接类订阅者一 订阅信号:发送网络数据
2017-05-31 20:36:08.569 RACDemo[1645:604549] 连接类订阅者二 订阅信号:发送网络数据
2017-05-31 20:36:08.569 RACDemo[1645:604549] 连接类订阅者三 订阅信号:发送网络数据

这样子我们就解决了频繁访问网络的问题。其实RACMulticastConnection主要就避免了多次调用创建信号中的block。

接下来让我们看看 RACMulticastConnection 底层是怎么实现的。

• 第一步创建RACSignal(原始信号)

RACSignal *signal = [RACSignal createSignal:^RACDisposable * _Nullable(id<RACSubscriber>  _Nonnull subscriber) {
 // block调用时刻：当RACMulticastConnection 调用 connect 方法的时候
// subscribe 此时的本质是一个 RACSubject.
// RACSubject sendNext:  遍历订阅者数组，让订阅者数组里面的每一个订阅者 都去调用他们的nextBlock。
// 上面三句看不懂，没关系，记着，接着往下看

        NSLog(@"请求网络数据");
        // 成功获取网络返回的数据，发送数据
        [subscriber sendNext:@"发送网络数据"];
        return nil;
    }];

• 第二步，将信号转换成连接类RACMulticastConnection。首先通过[signal publish]在底层创建一个RACSubject,再把RACSubject和RACSignal保存到RACMulticastConnection中，RACMulticastConnection中的_sourceSignal == RACSignal，_signal == RACSubject。

// signal 是 RACSignal 信号类
RACMulticastConnection *connection = [signal publish];

 // RACSignal class
 - (RACMulticastConnection *)publish {
    // 创建一个 RACSubject 信号类
    RACSubject *subject = [[RACSubject subject] setNameWithFormat:@"[%@] -publish", self.name];
// 返回连接类  RACMulticastConnection
    RACMulticastConnection *connection = [self multicast:subject];
    return connection;
}
  - (RACMulticastConnection *)multicast:(RACSubject *)subject {
    [subject setNameWithFormat:@"[%@] -multicast: %@", self.name, subject.name];
// 创建连接类RACMulticastConnection，传入一个RACSignal和一个RACSubject，self就是RACSignal
    RACMulticastConnection *connection = [[RACMulticastConnection alloc] initWithSourceSignal:self subject:subject];
    return connection;
}
 // RACMulticastConnection class
  - (instancetype)initWithSourceSignal:(RACSignal *)source subject:(RACSubject *)subject {
    NSCParameterAssert(source != nil);
    NSCParameterAssert(subject != nil);

    self = [super init];
//  _sourceSignal 是 RACSignal, _signal 是 RACSubject
    _sourceSignal = source;
    _serialDisposable = [[RACSerialDisposable alloc] init];
    _signal = subject;
    
    return self;
}

• 第三步，订阅连接类信号。

[connection.signal subscribeNext:^(id  _Nullable x) {
        NSLog(@"连接类订阅者一 订阅信号:%@",x);
    }];

上面说过了，connection.signal 中的signal就是RACSubject，在前两章有说过，RACSubject订阅信号的原理是 创建订阅者，保存nextBlock,将创建的订阅者存放到一个订阅者数组里面中去。

• 第四步，连接。[connection connect] 内部会订阅RACSignal(原始信号)，并且订阅者是RACSubject。订阅RACSignal，会调用第一步中的block。

  [connection connect];

  - (RACDisposable *)connect {
    BOOL shouldConnect = OSAtomicCompareAndSwap32Barrier(0, 1, &_hasConnected);

    if (shouldConnect) {
  // 重点这句，self.sourceSignal 就是RACSignal,_signal就是RACSubject.
//此处RACSignal订阅信号，订阅者就是RACSubject
// 订阅RACSignal，会调用第一步中创建信号的block。
        self.serialDisposable.disposable = [self.sourceSignal subscribe:_signal];
    }

    return self.serialDisposable;
}

总结

RACMulticastConnection 使用并不难，理解的话可能会有点绕。如果单纯看我写的可能会看不懂，建议自己去看下源码，可能更好理解一点。
自己在这里继续做下对RACMulticastConnection简短的总结

 1.创建RACSignal（原始信号） + (RACSignal *)createSignal:(RACDisposable * (^)(id<RACSubscriber> subscriber))didSubscribe
 2.创建连接  RACMulticastConnection *connection = [signal publish];
 2-1  connection 里面就包含了两个信号(sourceSignal,_signal)，一个是我们自己创建的RACSignal(原始信号),另外一个就是它在底层帮我们创建的RACSubject。
 3.订阅connection.signal 信号，其实就是订阅RACSubject信号。创建订阅者，订阅者保存nextBlock,将订阅者保存到一个数组中。
 4.连接[connection connect]。
 4-1.订阅RACSignal(原始信号)，订阅者就是RACSubject
 4-2.订阅原始信号，就会调用原始信号中的didSubscribe
 4-3.在didSubscribe中，拿到订阅者，调用sendNext，其实是调用RACSubject的sendNext
 4-4.RACSubject调用sendNext，其实就是会遍历RACSubject所有订阅者发送信号，调用它们保存的nextBlock.