RxJava 多播

Multicasting in RxJava (RxJava中的多播) 原文

Multicasting is a key method for reducing duplicated work in RxJava.
多路是一种解决在RxJava减少重复的有效方法。

When you multicast an event, you send the same event to all downstream operators/subscribers. This is useful when you're doing an expensive operation like a network request. You don't want to repeatedly execute identical network requests for each subscriber - you just want to execute one then multicast the results.

当你多播一个事件的时候，你发送了同样的事件给下流 operators/subscribers.。这是非常有用的，比如当你正在做一个网络请求操作时。你不想对每个订阅都做同样的网络请求操作--你只是想执行一次网络请求，然后把请求的结果多播出去。

There are two ways to multicast:
有两种方式去实现多播：

• Use a ConnectableObservable (via publish() or replay()1)
  使用一个ConnectableObservable ，通过publish() or replay()操作符实现。
• Use a Subject

---

Any work done before the ConnectableObservable or Subject will only happen once, then that work will be multicast to all downstream Subscribers.
任何在ConnectableObservable or Subject之前完成工作只会执行一次，接着把结果多播给所有的下流订阅者。

There is a subtle point here you must recognize: Streams only multicast at the point of the ConnectableObservable or Subject. As a result, any work done after the multicast is duplicated per Subscriber.
必须认识到一点：多播只会在使用 ConnectableObservable or Subject那个点发生。因此，对于多播以后的操作每个订阅者都会去执行。

Let's look at an example of how this can come into play:

Observable<String> observable = Observable.just("Event")  
    .publish()
    .autoConnect(2)
    .map(s -> {
      System.out.println("Expensive operation for " + s);
      return s;
    });

observable.subscribe(s -> System.out.println("Sub1 got: " + s));  
observable.subscribe(s -> System.out.println("Sub2 got: " + s));

// Output:
// Expensive operation for Event
// Sub1 got: Event
// Expensive operation for Event
// Sub2 got: Event
Here we have a ConnectableObservable, an expensive map() operation and two Subscribers. The surprising result is that the expensive map() operation is executed twice, even though we tried to prevent that with publish()!
从上面的结果来看，map（）操作执行了两次，尽管我们已经使用了publish()来实现多播。也就验证了只要使用了 ConnectableObservable（通过publish() or replay()操作符实现） or Subjec之后，那么后面的操作每个订阅者都会去执行。

This chart makes the situation clearer:

Chart showing why publish didn't work

If you actually wanted the map() to happen once, you would need to put it before the publish() call:
如果你想要map()只执行一次，你需要把map()操作放在publish()调用之前：

Observable<String> observable = Observable.just("Event")  
    .map(s -> {
      System.out.println("Expensive operation for " + s);
      return s;
    })
    .publish()
    .autoConnect(2);

observable.subscribe(s -> System.out.println("Sub1 got: " + s));  
observable.subscribe(s -> System.out.println("Sub2 got: " + s));

// Output:
// Expensive operation for Event
// Sub1 received: Event
// Sub2 received: Event
Here's an updated chart:

---

Chart with correct publish usage

What's the lesson here? If you're relying on multicasting to reduce work, make sure you multicast at the right point.
我们学到了什么？ 如果你想要通过multicasting （多播）来减少工作，确定你在正确的地方使用ConnectableObservable（通过publish() or replay() 操作符实现）。

For better or worse, a lot of people are using Subjects. One advantage is that they are multicast but you have to remember that they are only multicast at the point they emit. If you have a bunch of expensive operators applied downstream of the Subject then you should consider adding another publish() somewhere downstream.

不论好坏，好多人使用Subjects。一个好处它确实是多播的，但是它只会在发送事件（OnNext, OnComplete等）的地方多播。如果你下游要使用一些昂贵的操作符如（map())，最好在下游的某个地方给这个Subject 加一个publish() 操作符来减少工作。

share() and cache() are also options, but they are basically just shortcuts around ConnectableObservable. share() is just publish().refCount() and cache() can be recreated by using replay().autoConnect().

share()和cache()也是一个方法，但是它们也只不过是ConnectableObservable的简写。share()可以使用publish().refCount() ，cache()使用replay().autoConnect()来代替。