[英]RxJava: How to Subscribe only if the Observable is Cold?
TL; DR:如何創建一個Observable,如果它是冷的 ,只創建一個Subscription,並在它很熱的時候排隊任何其他的subscribe調用?
我想創建一個Observable,它一次只能執行一個Subscription 。 如果任何其他訂閱者訂閱了Observable,我希望它們在Observable完成時排隊等待運行(在onComplete之后)。
我可以通過在每個onComplete上使用某種堆棧並彈出堆棧來自己構建這個構造 - 但感覺這個功能已經存在於RxJava中。
有沒有辦法以這種方式限制訂閱?
沒有內置的運算符或我能想到的運算符組合可以實現這一目標。 這是我如何實現它:
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.*;
import rx.*;
import rx.observers.TestSubscriber;
import rx.subjects.PublishSubject;
import rx.subscriptions.Subscriptions;
public final class SequenceSubscribers<T> implements Observable.OnSubscribe<T> {
final Observable<? extends T> source;
final Queue<Subscriber<? super T>> queue;
final AtomicInteger wip;
volatile boolean active;
public SequenceSubscribers(Observable<? extends T> source) {
this.source = source;
this.queue = new ConcurrentLinkedQueue<>();
this.wip = new AtomicInteger();
}
@Override
public void call(Subscriber<? super T> t) {
SubscriberWrapper wrapper = new SubscriberWrapper(t);
queue.add(wrapper);
t.add(wrapper);
t.add(Subscriptions.create(() -> wrapper.next()));
drain();
}
void complete(SubscriberWrapper inner) {
active = false;
drain();
}
void drain() {
if (wip.getAndIncrement() != 0) {
return;
}
do {
if (!active) {
Subscriber<? super T> s = queue.poll();
if (s != null && !s.isUnsubscribed()) {
active = true;
source.subscribe(s);
}
}
} while (wip.decrementAndGet() != 0);
}
final class SubscriberWrapper extends Subscriber<T> {
final Subscriber<? super T> actual;
final AtomicBoolean once;
public SubscriberWrapper(Subscriber<? super T> actual) {
this.actual = actual;
this.once = new AtomicBoolean();
}
@Override
public void onNext(T t) {
actual.onNext(t);
}
@Override
public void onError(Throwable e) {
actual.onError(e);
next();
}
@Override
public void onCompleted() {
actual.onCompleted();
next();
}
@Override
public void setProducer(Producer p) {
actual.setProducer(p);
}
void next() {
if (once.compareAndSet(false, true)) {
complete(this);
}
}
}
public static void main(String[] args) {
PublishSubject<Integer> ps = PublishSubject.create();
TestSubscriber<Integer> ts1 = TestSubscriber.create();
TestSubscriber<Integer> ts2 = TestSubscriber.create();
Observable<Integer> source = Observable.create(new SequenceSubscribers<>(ps));
source.subscribe(ts1);
source.subscribe(ts2);
ps.onNext(1);
ps.onNext(2);
ts1.assertValues(1, 2);
ts2.assertNoValues();
ts1.unsubscribe();
ps.onNext(3);
ps.onNext(4);
ps.onCompleted();
ts1.assertValues(1, 2);
ts2.assertValues(3, 4);
ts2.assertCompleted();
}
}
我假設你有一個潛在的冷觀察,你想多次訂閱,但只有前一個訂閱完成。
我們可以巧妙地使用可以延遲新訂閱的函數delaySubscription
。 下一個障礙是在先前訂閱完成時觸發訂閱。 我們使用doOnUnsubscribe
執行此doOnUnsubscribe
,該操作會在取消訂閱, onError
和onCompleted
操作上觸發。
public class DelaySubscribe<T> {
Observable<Integer> previouse = Observable.just(0);
private DelaySubscribe() {
}
public static <T> Observable<T> makeDelayOb(Observable<T> cold) {
return new DelaySubscribe<T>().obs(cold);
}
private Observable<T> obs(Observable<T> cold) {
return Observable.create(ob -> {
Observable<Integer> tmp = previouse;
ReplaySubject<Integer> rep = ReplaySubject.create();
previouse = rep;
cold.delaySubscription(() -> tmp).doOnUnsubscribe(() -> {
rep.onNext(0);
rep.onCompleted();
}).subscribe(ob);
});
}
用法示例:
public static void main(String[] args) throws IOException, InterruptedException {
Observable<Long> cold = Observable.interval(1, TimeUnit.SECONDS).take(2);
Observable<Long> hot = makeDelayOb(cold);
Func1<Integer, rx.Observer<Long>> obs = (Integer i) -> Observers.create(el -> System.out.println(i + "next: " + el),
er -> System.out.println(i + "error: " + er), () -> System.out.println(i + "completed"));
System.out.println("1");
Subscription s = hot.subscribe(obs.call(1));
System.out.println("2");
hot.subscribe(obs.call(2));
Thread.sleep(1500);
s.unsubscribe();
System.out.println("3");
Thread.sleep(3500);
hot.subscribe(obs.call(3));
System.out.println("4");
System.in.read();
}
}
輸出:
1
2
1next: 0
3
2next: 0
2next: 1
2completed
4
3next: 0
3next: 1
3completed
我假設您有一個具有多個訂閱的熱觀察,但只希望一個訂閱接收事件。 一旦當前訂閱取消訂閱,下一個訂閱應該開始接收。
我們可以做的是給每個訂閱和唯一號碼,並保留所有訂閱的列表。 只有列表中的第一個訂閱接收事件,其余訂閱filter
掉事件。
public class SingleSubscribe {
List<Integer> current = Collections.synchronizedList(new ArrayList<>());
int max = 0;
Object gate = new Object();
private SingleSubscribe() {
}
public static <T> Transformer<T, T> singleSubscribe() {
return new SingleSubscribe().obs();
}
private <T> Transformer<T, T> obs() {
return (source) -> Observable.create((Subscriber<? super T> ob) -> {
Integer me;
synchronized (gate) {
me = max++;
}
current.add(me);
source.doOnUnsubscribe(() -> current.remove(me)).filter(__ -> {
return current.get(0) == me;
}).subscribe(ob);
});
}
用法示例:
public static void main(String[] args) throws InterruptedException, IOException {
ConnectableObservable<Long> connectable = Observable.interval(500, TimeUnit.MILLISECONDS)
.publish();
Observable<Long> hot = connectable.compose(SingleSubscribe.<Long> singleSubscribe());
Subscription sub = connectable.connect();
Func1<Integer, rx.Observer<Long>> obs = (Integer i) -> Observers.create(el -> System.out.println(i + "next: " + el),
er -> {
System.out.println(i + "error: " + er);
er.printStackTrace();
} , () -> System.out.println(i + "completed"));
System.out.println("1");
Subscription s = hot.subscribe(obs.call(1));
System.out.println("2");
hot.take(4).subscribe(obs.call(2));
Thread.sleep(1500);
s.unsubscribe();
System.out.println("3");
Thread.sleep(500);
hot.take(2).subscribe(obs.call(3));
System.out.println("4");
System.in.read();
sub.unsubscribe();
}
}
輸出:
1
2
1next: 0
1next: 1
1next: 2
3
2next: 3
4
2next: 4
2next: 5
2next: 6
2completed
3next: 6
3next: 7
3completed
請注意,輸出中存在一個小缺陷:因為2在取得6之后立即取消訂閱,但在3之前接收6次。在2次取消訂閱之后,3是下一個活躍的觀察者並愉快地接受6。
解決方案是延遲doOnUnsubscribe
,最簡單的方法是在新的線程調度程序上安排操作:
source.doOnUnsubscribe(() -> Schedulers.newThread().createWorker().schedule(()-> current.remove(me)))
但是,這意味着當2次取消訂閱時,下一個項目被忽略,並且下一個項目在激活3之前到達時,現在很有可能。 使用最適合您的變體。
最后,這個解決方案絕對假設源是熱的。 我不確定將此運算符應用於冷可觀察量時會發生什么,但結果可能是意外的。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.