Debian Codegraph @

src/main/java/io/reactivex/rxjava3/internal/operators/flowable/FlowableObserveOn.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.flowable;
15
16 import java.util.concurrent.atomic.AtomicLong;
17
18 import org.reactivestreams.*;
19
20 import io.reactivex.rxjava3.annotations.Nullable;
21 import io.reactivex.rxjava3.core.*;
22 import io.reactivex.rxjava3.core.Scheduler.Worker;
23 import io.reactivex.rxjava3.exceptions.*;
24 import io.reactivex.rxjava3.internal.subscriptions.*;
25 import io.reactivex.rxjava3.internal.util.BackpressureHelper;
26 import io.reactivex.rxjava3.operators.ConditionalSubscriber;
27 import io.reactivex.rxjava3.operators.QueueSubscription;
28 import io.reactivex.rxjava3.operators.SimpleQueue;
29 import io.reactivex.rxjava3.operators.SpscArrayQueue;
30 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
31
32 public final class FlowableObserveOn<T> extends AbstractFlowableWithUpstream<T, T> {
33 final Scheduler scheduler;
34
35 final boolean delayError;
36
37 final int prefetch;
38
39 public FlowableObserveOn(
40 Flowable<T> source,
41 Scheduler scheduler,
42 boolean delayError,
43 int prefetch) {
44 super(source);
45 this.scheduler = scheduler;
46 this.delayError = delayError;
47 this.prefetch = prefetch;
48 }
49
50 @Override
51 public void subscribeActual(Subscriber<? super T> s) {
52 Worker worker = scheduler.createWorker();
53
54 if (s instanceof ConditionalSubscriber) {
55 source.subscribe(new ObserveOnConditionalSubscriber<>(
56 (ConditionalSubscriber<? super T>) s, worker, delayError, prefetch));
57 } else {
58 source.subscribe(new ObserveOnSubscriber<>(s, worker, delayError, prefetch));
59 }
60 }
61
62 abstract static class BaseObserveOnSubscriber<T>
63 extends BasicIntQueueSubscription<T>
64 implements FlowableSubscriber<T>, Runnable {
65 private static final long serialVersionUID = -8241002408341274697L;
66
67 final Worker worker;
68
69 final boolean delayError;
70
71 final int prefetch;
72
73 final int limit;
74
75 final AtomicLong requested;
76
77 Subscription upstream;
78
79 SimpleQueue<T> queue;
80
81 volatile boolean cancelled;
82
83 volatile boolean done;
84
85 Throwable error;
86
87 int sourceMode;
88
89 long produced;
90
91 boolean outputFused;
92
93 BaseObserveOnSubscriber(
94 Worker worker,
95 boolean delayError,
96 int prefetch) {
97 this.worker = worker;
98 this.delayError = delayError;
99 this.prefetch = prefetch;
100 this.requested = new AtomicLong();
101 this.limit = prefetch - (prefetch >> 2);
102 }
103
104 @Override
105 public final void onNext(T t) {
106 if (done) {
107 return;
108 }
109 if (sourceMode == ASYNC) {
110 trySchedule();
111 return;
112 }
113 if (!queue.offer(t)) {
114 upstream.cancel();
115
116 error = new MissingBackpressureException("Queue is full?!");
117 done = true;
118 }
119 trySchedule();
120 }
121
122 @Override
123 public final void onError(Throwable t) {
124 if (done) {
125 RxJavaPlugins.onError(t);
126 return;
127 }
128 error = t;
129 done = true;
130 trySchedule();
131 }
132
133 @Override
134 public final void onComplete() {
135 if (!done) {
136 done = true;
137 trySchedule();
138 }
139 }
140
141 @Override
142 public final void request(long n) {
143 if (SubscriptionHelper.validate(n)) {
144 BackpressureHelper.add(requested, n);
145 trySchedule();
146 }
147 }
148
149 @Override
150 public final void cancel() {
151 if (cancelled) {
152 return;
153 }
154
155 cancelled = true;
156 upstream.cancel();
157 worker.dispose();
158
159 if (!outputFused && getAndIncrement() == 0) {
160 queue.clear();
161 }
162 }
163
164 final void trySchedule() {
165 if (getAndIncrement() != 0) {
166 return;
167 }
168 worker.schedule(this);
169 }
170
171 @Override
172 public final void run() {
173 if (outputFused) {
174 runBackfused();
175 } else if (sourceMode == SYNC) {
176 runSync();
177 } else {
178 runAsync();
179 }
180 }
181
182 abstract void runBackfused();
183
184 abstract void runSync();
185
186 abstract void runAsync();
187
188 final boolean checkTerminated(boolean d, boolean empty, Subscriber<?> a) {
189 if (cancelled) {
190 clear();
191 return true;
192 }
193 if (d) {
194 if (delayError) {
195 if (empty) {
196 cancelled = true;
197 Throwable e = error;
198 if (e != null) {
199 a.onError(e);
200 } else {
201 a.onComplete();
202 }
203 worker.dispose();
204 return true;
205 }
206 } else {
207 Throwable e = error;
208 if (e != null) {
209 cancelled = true;
210 clear();
211 a.onError(e);
212 worker.dispose();
213 return true;
214 } else
215 if (empty) {
216 cancelled = true;
217 a.onComplete();
218 worker.dispose();
219 return true;
220 }
221 }
222 }
223
224 return false;
225 }
226
227 @Override
228 public final int requestFusion(int requestedMode) {
229 if ((requestedMode & ASYNC) != 0) {
230 outputFused = true;
231 return ASYNC;
232 }
233 return NONE;
234 }
235
236 @Override
237 public final void clear() {
238 queue.clear();
239 }
240
241 @Override
242 public final boolean isEmpty() {
243 return queue.isEmpty();
244 }
245 }
246
247 static final class ObserveOnSubscriber<T> extends BaseObserveOnSubscriber<T>
248 implements FlowableSubscriber<T> {
249
250 private static final long serialVersionUID = -4547113800637756442L;
251
252 final Subscriber<? super T> downstream;
253
254 ObserveOnSubscriber(
255 Subscriber<? super T> actual,
256 Worker worker,
257 boolean delayError,
258 int prefetch) {
259 super(worker, delayError, prefetch);
260 this.downstream = actual;
261 }
262
263 @Override
264 public void onSubscribe(Subscription s) {
265 if (SubscriptionHelper.validate(this.upstream, s)) {
266 this.upstream = s;
267
268 if (s instanceof QueueSubscription) {
269 @SuppressWarnings("unchecked")
270 QueueSubscription<T> f = (QueueSubscription<T>) s;
271
272 int m = f.requestFusion(ANY | BOUNDARY);
273
274 if (m == SYNC) {
275 sourceMode = SYNC;
276 queue = f;
277 done = true;
278
279 downstream.onSubscribe(this);
280 return;
281 } else
282 if (m == ASYNC) {
283 sourceMode = ASYNC;
284 queue = f;
285
286 downstream.onSubscribe(this);
287
288 s.request(prefetch);
289
290 return;
291 }
292 }
293
294 queue = new SpscArrayQueue<>(prefetch);
295
296 downstream.onSubscribe(this);
297
298 s.request(prefetch);
299 }
300 }
301
302 @Override
303 void runSync() {
304 int missed = 1;
305
306 final Subscriber<? super T> a = downstream;
307 final SimpleQueue<T> q = queue;
308
309 long e = produced;
310
311 for (;;) {
312
313 long r = requested.get();
314
315 while (e != r) {
316 T v;
317
318 try {
319 v = q.poll();
320 } catch (Throwable ex) {
321 Exceptions.throwIfFatal(ex);
322 cancelled = true;
323 upstream.cancel();
324 a.onError(ex);
325 worker.dispose();
326 return;
327 }
328
329 if (cancelled) {
330 return;
331 }
332 if (v == null) {
333 cancelled = true;
334 a.onComplete();
335 worker.dispose();
336 return;
337 }
338
339 a.onNext(v);
340
341 e++;
342 }
343
344 if (cancelled) {
345 return;
346 }
347
348 if (q.isEmpty()) {
349 cancelled = true;
350 a.onComplete();
351 worker.dispose();
352 return;
353 }
354
355 produced = e;
356 missed = addAndGet(-missed);
357 if (missed == 0) {
358 break;
359 }
360 }
361 }
362
363 @Override
364 void runAsync() {
365 int missed = 1;
366
367 final Subscriber<? super T> a = downstream;
368 final SimpleQueue<T> q = queue;
369
370 long e = produced;
371
372 for (;;) {
373
374 long r = requested.get();
375
376 while (e != r) {
377 boolean d = done;
378 T v;
379
380 try {
381 v = q.poll();
382 } catch (Throwable ex) {
383 Exceptions.throwIfFatal(ex);
384
385 cancelled = true;
386 upstream.cancel();
387 q.clear();
388
389 a.onError(ex);
390 worker.dispose();
391 return;
392 }
393
394 boolean empty = v == null;
395
396 if (checkTerminated(d, empty, a)) {
397 return;
398 }
399
400 if (empty) {
401 break;
402 }
403
404 a.onNext(v);
405
406 e++;
407 if (e == limit) {
408 if (r != Long.MAX_VALUE) {
409 r = requested.addAndGet(-e);
410 }
411 upstream.request(e);
412 e = 0L;
413 }
414 }
415
416 if (e == r && checkTerminated(done, q.isEmpty(), a)) {
417 return;
418 }
419
420 int w = get();
421 if (missed == w) {
422 produced = e;
423 missed = addAndGet(-missed);
424 if (missed == 0) {
425 break;
426 }
427 } else {
428 missed = w;
429 }
430 }
431 }
432
433 @Override
434 void runBackfused() {
435 int missed = 1;
436
437 for (;;) {
438
439 if (cancelled) {
440 return;
441 }
442
443 boolean d = done;
444
445 downstream.onNext(null);
446
447 if (d) {
448 cancelled = true;
449 Throwable e = error;
450 if (e != null) {
451 downstream.onError(e);
452 } else {
453 downstream.onComplete();
454 }
455 worker.dispose();
456 return;
457 }
458
459 missed = addAndGet(-missed);
460 if (missed == 0) {
461 break;
462 }
463 }
464 }
465
466 @Nullable
467 @Override
468 public T poll() throws Throwable {
469 T v = queue.poll();
470 if (v != null && sourceMode != SYNC) {
471 long p = produced + 1;
472 if (p == limit) {
473 produced = 0;
474 upstream.request(p);
475 } else {
476 produced = p;
477 }
478 }
479 return v;
480 }
481
482 }
483
484 static final class ObserveOnConditionalSubscriber<T>
485 extends BaseObserveOnSubscriber<T> {
486
487 private static final long serialVersionUID = 644624475404284533L;
488
489 final ConditionalSubscriber<? super T> downstream;
490
491 long consumed;
492
493 ObserveOnConditionalSubscriber(
494 ConditionalSubscriber<? super T> actual,
495 Worker worker,
496 boolean delayError,
497 int prefetch) {
498 super(worker, delayError, prefetch);
499 this.downstream = actual;
500 }
501
502 @Override
503 public void onSubscribe(Subscription s) {
504 if (SubscriptionHelper.validate(this.upstream, s)) {
505 this.upstream = s;
506
507 if (s instanceof QueueSubscription) {
508 @SuppressWarnings("unchecked")
509 QueueSubscription<T> f = (QueueSubscription<T>) s;
510
511 int m = f.requestFusion(ANY | BOUNDARY);
512
513 if (m == SYNC) {
514 sourceMode = SYNC;
515 queue = f;
516 done = true;
517
518 downstream.onSubscribe(this);
519 return;
520 } else
521 if (m == ASYNC) {
522 sourceMode = ASYNC;
523 queue = f;
524
525 downstream.onSubscribe(this);
526
527 s.request(prefetch);
528
529 return;
530 }
531 }
532
533 queue = new SpscArrayQueue<>(prefetch);
534
535 downstream.onSubscribe(this);
536
537 s.request(prefetch);
538 }
539 }
540
541 @Override
542 void runSync() {
543 int missed = 1;
544
545 final ConditionalSubscriber<? super T> a = downstream;
546 final SimpleQueue<T> q = queue;
547
548 long e = produced;
549
550 for (;;) {
551
552 long r = requested.get();
553
554 while (e != r) {
555 T v;
556 try {
557 v = q.poll();
558 } catch (Throwable ex) {
559 Exceptions.throwIfFatal(ex);
560 cancelled = true;
561 upstream.cancel();
562 a.onError(ex);
563 worker.dispose();
564 return;
565 }
566
567 if (cancelled) {
568 return;
569 }
570 if (v == null) {
571 cancelled = true;
572 a.onComplete();
573 worker.dispose();
574 return;
575 }
576
577 if (a.tryOnNext(v)) {
578 e++;
579 }
580 }
581
582 if (cancelled) {
583 return;
584 }
585
586 if (q.isEmpty()) {
587 cancelled = true;
588 a.onComplete();
589 worker.dispose();
590 return;
591 }
592
593 produced = e;
594 missed = addAndGet(-missed);
595 if (missed == 0) {
596 break;
597 }
598 }
599 }
600
601 @Override
602 void runAsync() {
603 int missed = 1;
604
605 final ConditionalSubscriber<? super T> a = downstream;
606 final SimpleQueue<T> q = queue;
607
608 long emitted = produced;
609 long polled = consumed;
610
611 for (;;) {
612
613 long r = requested.get();
614
615 while (emitted != r) {
616 boolean d = done;
617 T v;
618 try {
619 v = q.poll();
620 } catch (Throwable ex) {
621 Exceptions.throwIfFatal(ex);
622
623 cancelled = true;
624 upstream.cancel();
625 q.clear();
626
627 a.onError(ex);
628 worker.dispose();
629 return;
630 }
631 boolean empty = v == null;
632
633 if (checkTerminated(d, empty, a)) {
634 return;
635 }
636
637 if (empty) {
638 break;
639 }
640
641 if (a.tryOnNext(v)) {
642 emitted++;
643 }
644
645 polled++;
646
647 if (polled == limit) {
648 upstream.request(polled);
649 polled = 0L;
650 }
651 }
652
653 if (emitted == r && checkTerminated(done, q.isEmpty(), a)) {
654 return;
655 }
656
657 produced = emitted;
658 consumed = polled;
659 missed = addAndGet(-missed);
660 if (missed == 0) {
661 break;
662 }
663 }
664
665 }
666
667 @Override
668 void runBackfused() {
669 int missed = 1;
670
671 for (;;) {
672
673 if (cancelled) {
674 return;
675 }
676
677 boolean d = done;
678
679 downstream.onNext(null);
680
681 if (d) {
682 cancelled = true;
683 Throwable e = error;
684 if (e != null) {
685 downstream.onError(e);
686 } else {
687 downstream.onComplete();
688 }
689 worker.dispose();
690 return;
691 }
692
693 missed = addAndGet(-missed);
694 if (missed == 0) {
695 break;
696 }
697 }
698 }
699
700 @Nullable
701 @Override
702 public T poll() throws Throwable {
703 T v = queue.poll();
704 if (v != null && sourceMode != SYNC) {
705 long p = consumed + 1;
706 if (p == limit) {
707 consumed = 0;
708 upstream.request(p);
709 } else {
710 consumed = p;
711 }
712 }
713 return v;
714 }
715 }
716 }